@dashfoo/core 1.0.0 → 1.1.0

package/dist/index.js

@@ -2,11 +2,8 @@ import { z } from "zod";
 import { assign, emit, setup } from "xstate";
 
 //#region src/lib/clamp-selected.ts
-/**
-* Lives in `lib/` rather than beside `normalize`, because both the parse
-* boundary (`tabsetNodeSchema`) and the tree walker that `normalize` uses need
-* it, and importing it from either one would close a module cycle.
-*/
+/** 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;
@@ -17,14 +14,7 @@ const clampSelected = (length, selected) => {
 
 //#endregion
 //#region src/model/schema.ts
-/**
-* Weights are relative shares, and every reader that rendered one already
-* treated a missing weight as a single share (`row-view` summed `weight ?? 1`),
-* so filling it in at the boundary changes nothing on screen. The one place that
-* read a missing weight as a percentage was `placeBesideTarget`, which is why
-* docking beside an unweighted target halved it to `50` and left its unweighted
-* siblings rendering as a sliver of the row.
-*/
+/** Weights are relative shares of a row, not percentages. */
 const DEFAULT_WEIGHT = 1;
 const jsonValueSchema = z.lazy(() => z.union([
 	z.string(),
@@ -69,11 +59,8 @@ const tabNodeSchema = z.object({
 	type: z.literal("tab")
 });
 /**
-* The pre-transform object, kept separate so `node-attrs` can `.pick()` mutable
-* keys off it. Picking from the transformed schema is impossible (a pipe has no
-* `.pick`), and picking `weight` with its default attached would inject that
-* default: `.partial()` over a defaulted field still fills it in, which would
-* rewrite a tabset's weight on every unrelated attribute update.
+* 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),
@@ -91,8 +78,11 @@ const tabsetNodeSchema = tabsetNodeObjectSchema.transform((tabset) => ({
 	...tabset,
 	selected: clampSelected(tabset.children.length, tabset.selected)
 }));
-const rowNodeSchema = z.lazy(() => z.object({
-	children: z.array(z.union([rowNodeSchema, tabsetNodeSchema])),
+/** 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(),
@@ -100,7 +90,7 @@ const rowNodeSchema = z.lazy(() => z.object({
 	snap: snapSchema.optional(),
 	type: z.literal("row"),
 	weight: z.number().default(1)
-}));
+});
 const geometrySchema = z.object({
 	height: z.number(),
 	left: z.number(),
@@ -146,11 +136,7 @@ const mutableTabAttrsSchema = tabNodeSchema.pick({
 	enableRename: true,
 	name: true
 }).partial();
-/**
-* `weight` is re-declared instead of picked: `.partial()` over the schema's
-* defaulted `weight` still injects the default, so `{ name: "x" }` would arrive
-* at the reducer carrying a weight and silently resize the tabset.
-*/
+/** `weight` is re-declared, not picked: `.partial()` over a defaulted field still injects the default. */
 const mutableTabsetAttrsSchema = tabsetNodeObjectSchema.pick({
 	enableClose: true,
 	enableMaximize: true,
@@ -166,13 +152,8 @@ const mutableRowAttrsSchema = z.object({
 	weight: z.number()
 }).partial();
 /**
-* One all-optional object carrying every mutable key of every node kind, not a
-* union of the three: a union whose members are all fully optional matches on
-* its first member and strips the keys the others own, which erased every
-* tabset and row attribute at the parse boundary. The four keys that two kinds
-* share (`enableClose`, `max`, `min`, `weight`) declare the same type on both
-* sides, so merging widens nothing. Which keys are legal for a given node is
-* enforced by the reducer against that node's own schema.
+* 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);
 
@@ -202,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(),
@@ -293,16 +273,9 @@ const createTabId = () => createNodeId("tab");
 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({
@@ -333,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);
@@ -345,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;
@@ -487,13 +460,6 @@ const closestEdge = (d) => {
 	if (min === d.top) return "top";
 	return "bottom";
 };
-const dockLocationFor = (target) => {
-	switch (target.kind) {
-		case "split": return `split-${target.edge}`;
-		case "tab": return "center";
-		default: return assertNever(target);
-	}
-};
 const splitEdge = (location) => {
 	switch (location) {
 		case "center": return;
@@ -506,13 +472,10 @@ const splitEdge = (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;
@@ -661,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
 	};
@@ -699,28 +661,25 @@ const snapSizes = (sizes, boundaryIndex, config) => {
 		snapped: true
 	};
 };
-const decideSnap = (sizes, boundaryIndex, config) => {
-	if (boundaryIndex === null || config === null || !snapEnabled(config)) return { kind: "inactive" };
-	const { sizes: snappedSizes, snapped } = snapSizes(sizes, boundaryIndex, config);
+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, config) => {
-	const decision = decideSnap(sizes, boundaryIndex, config);
+const settleSnap = (sizes, boundaryIndex, grid) => {
+	const decision = decideSnap(sizes, boundaryIndex, grid);
 	return decision.kind === "engage" ? decision.sizes : sizes;
 };
 
 //#endregion
 //#region src/model/invariants.ts
 /**
-* 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 = {
@@ -735,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(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];
@@ -756,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") {
@@ -773,53 +735,67 @@ const normalizeLayout = (root) => {
 	};
 };
 const normalize = (model) => {
-	const layout = normalizeLayout(model.layout);
+	const mainTabsetIds = [];
+	const layout = normalizeLayout(model.layout, mainTabsetIds);
 	const floats = [];
+	const floatTabsetIds = [];
 	for (const float of model.floats) {
-		const floatLayout = normalizeLayout(float.layout);
-		if (rowContainsTabset(floatLayout)) floats.push({
-			...float,
-			layout: floatLayout
-		});
+		const ownTabsetIds = [];
+		const floatLayout = normalizeLayout(float.layout, ownTabsetIds);
+		if (floatLayout.children.length > 0) {
+			floats.push({
+				...float,
+				layout: floatLayout
+			});
+			floatTabsetIds.push(...ownTabsetIds);
+		}
 	}
-	const withRoots = {
-		...model,
-		floats,
-		layout
-	};
-	const tabsets = collectTabsets(withRoots);
-	const tabsetIds = new Set(tabsets.map((tabset) => tabset.id));
-	const firstTabsetId = tabsets[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 splitPlacement = (location) => {
-	const edge = splitEdge(location);
-	return {
-		before: edge === "left" || edge === "top",
-		orientation: edge === "left" || edge === "right" ? "row" : "column"
-	};
+/** 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 { before, orientation } = splitPlacement(location);
+	const found = findTabsetParent(draft, targetId);
+	if (!targetTabset || !found) return false;
+	const { before, orientation } = SPLIT_PLACEMENT[location];
 	if (found.parent.orientation === orientation) {
 		const half = targetTabset.weight / 2;
 		targetTabset.weight = half;
@@ -838,16 +814,17 @@ const placeBesideTarget = (draft, placed, targetId, location) => {
 		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 = 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],
@@ -856,13 +833,9 @@ const insertTab = (draft, tab, target) => {
 		type: "tabset",
 		weight: 1
 	};
-	placeBesideTarget(draft, newTabset, targetId, location);
+	return placeBesideTarget(draft, newTabset, targetId, location);
 };
-/**
-* Removing a tab can leave `selected` past the end of the strip, so every
-* detach re-clamps its container rather than leaving the whole tree to be
-* re-walked afterwards.
-*/
+/** 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);
@@ -924,10 +897,10 @@ const pushFloat = (draft, layout, geometry, floatId) => {
 	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 = [];
@@ -943,36 +916,35 @@ 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);
-	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";
-	placeBesideTarget(draft, tabsets.length === 1 && leadTabset ? leadTabset : {
+	const placed = tabsets.length === 1 && leadTabset ? leadTabset : {
 		children: tabs,
 		id: createNodeId("tabset"),
 		selected: selectedOffset,
 		type: "tabset",
 		weight: 1
-	}, target.id, where);
+	};
+	return placeBesideTarget(draft, placed, target.id, location ?? "split-right");
 };
 
 //#endregion
@@ -991,127 +963,138 @@ const parseNodeAttrs = (node, attrs) => {
 		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) detachTab(location.container, location.index);
-			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;
+			if (!location) return false;
 			const removed = detachTab(location.container, location.index);
-			if (removed) pushFloat(draft, wrapTabInLayout(removed), action.geometry, action.floatId);
-			return;
+			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;
+			if (!source || !findTabset(draft, action.targetId)) return false;
 			const removed = detachTab(source.container, source.index);
-			if (!removed) return;
-			insertTab(draft, removed, {
+			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;
 			}
-			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 = clampSelected(tabset.children.length, 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, parseNodeAttrs(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);
 };
 
@@ -1125,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),
@@ -1172,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: {
@@ -1198,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"
 			} }
 		}
@@ -1269,5 +1277,5 @@ const stackModel = (model, orientation = "column") => {
 };
 
 //#endregion
-export { DEFAULT_SNAP_THRESHOLD, DEFAULT_WEIGHT, HISTORY_LIMIT, actionSchema, canRedo, canUndo, collectRoots, collectTabsets, collectTabsetsInRow, createHistory, createNodeId, createTabId, dashfooMachine, dashfooSchema, decideSnap, dimensionSchema, dispatch, dockLocationFor, 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, settleSnap, snapEnabled, snapSchema, snapSizes, splitEdge, stackModel, tab, tabNodeSchema, tabset, tabsetNodeObjectSchema, 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