@dashfoo/core 0.5.1 → 1.0.0

package/dist/index.js

@@ -1,7 +1,31 @@
 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.
+*/
+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, 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.
+*/
+const DEFAULT_WEIGHT = 1;
 const jsonValueSchema = z.lazy(() => z.union([
 	z.string(),
 	z.number(),
@@ -44,7 +68,14 @@ const tabNodeSchema = z.object({
 	name: z.string(),
 	type: z.literal("tab")
 });
-const tabsetNodeSchema = z.object({
+/**
+* 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.
+*/
+const tabsetNodeObjectSchema = z.object({
 	children: z.array(tabNodeSchema),
 	enableClose: z.boolean().optional(),
 	enableMaximize: z.boolean().optional(),
@@ -54,8 +85,12 @@ 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 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])),
 	id: z.string(),
@@ -64,7 +99,7 @@ const rowNodeSchema = z.lazy(() => z.object({
 	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(),
@@ -95,15 +130,15 @@ const globalAttributesSchema = z.object({
 });
 const dashfooSchema = z.object({
 	activeTabsetId: z.string().optional(),
+	floats: z.array(floatNodeSchema).default(() => []),
 	global: globalAttributesSchema,
 	layout: rowNodeSchema,
 	maximizedTabsetId: z.string().optional(),
-	version: z.literal(1),
-	floats: z.array(floatNodeSchema).optional()
+	version: z.literal(1)
 });
 
 //#endregion
-//#region src/state/actions.ts
+//#region src/state/node-attrs.ts
 const mutableTabAttrsSchema = tabNodeSchema.pick({
 	config: true,
 	enableClose: true,
@@ -111,14 +146,18 @@ const mutableTabAttrsSchema = tabNodeSchema.pick({
 	enableRename: true,
 	name: true
 }).partial();
-const mutableTabsetAttrsSchema = tabsetNodeSchema.pick({
+/**
+* `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.
+*/
+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 +165,19 @@ const mutableRowAttrsSchema = z.object({
 	snap: snapSchema.optional(),
 	weight: z.number()
 }).partial();
-const mutableNodeAttrsSchema = z.union([
-	mutableTabAttrsSchema,
-	mutableTabsetAttrsSchema,
-	mutableRowAttrsSchema
-]);
+/**
+* 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.
+*/
+const mutableNodeAttrsSchema = mutableTabAttrsSchema.extend(mutableTabsetAttrsSchema.shape).extend(mutableRowAttrsSchema.shape);
+
+//#endregion
+//#region src/state/actions.ts
 const dockLocationSchema = z.enum([
 	"center",
 	"split-bottom",
@@ -138,6 +185,7 @@ const dockLocationSchema = z.enum([
 	"split-right",
 	"split-top"
 ]);
+const splitWeightsSchema = z.array(z.number());
 const actionSchema = z.discriminatedUnion("type", [
 	z.object({
 		index: z.number().int().optional(),
@@ -189,7 +237,7 @@ const actionSchema = z.discriminatedUnion("type", [
 	z.object({
 		rowId: z.string(),
 		type: z.literal("adjustSplit"),
-		weights: z.array(z.number())
+		weights: splitWeightsSchema
 	}),
 	z.object({
 		attrs: mutableNodeAttrsSchema,
@@ -242,11 +290,54 @@ 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.
+*/
+const walk = (row, visit, parent, index = -1) => {
+	const atRoot = visit({
+		index,
+		node: row,
+		parent
+	});
+	if (atRoot !== void 0) return atRoot;
+	for (const [childIndex, child] of row.children.entries()) {
+		if (child.type === "row") {
+			const inRow = walk(child, visit, row, childIndex);
+			if (inRow !== void 0) return inRow;
+			continue;
+		}
+		const atTabset = visit({
+			index: childIndex,
+			node: child,
+			parent: row
+		});
+		if (atTabset !== void 0) return atTabset;
+		for (const [tabIndex, tab] of child.children.entries()) {
+			const atTab = visit({
+				index: tabIndex,
+				node: tab,
+				parent: child
+			});
+			if (atTab !== void 0) return atTab;
+		}
+	}
+};
+const locate = (row, id) => walk(row, (found) => found.node.id === id ? found : void 0);
 const collectTabsetsInRow = (row, acc) => {
-	for (const child of row.children) if (child.type === "tabset") acc.push(child);
-	else collectTabsetsInRow(child, acc);
+	walk(row, ({ node }) => {
+		if (node.type === "tabset") acc.push(node);
+	});
 };
 const collectTabsets = (model) => {
 	const acc = [];
@@ -258,7 +349,7 @@ const findTabset = (model, tabsetId) => collectTabsets(model).find((tabset) => t
 const findTabInContainer = (container, tabId) => {
 	const index = container.children.findIndex((tab) => tab.id === tabId);
 	if (index === -1) return;
-	const tab = container.children[index];
+	const tab = container.children.at(index);
 	if (!tab) return;
 	return {
 		container,
@@ -273,25 +364,10 @@ const findTab = (model, tabId) => {
 	}
 };
 const findRow = (row, id) => {
-	if (row.id === id) return row;
-	for (const child of row.children) if (child.type === "row") {
-		const found = findRow(child, id);
-		if (found) return found;
-	}
-};
-const findAttributedNodeInRow = (row, id) => {
-	if (row.id === id) return row;
-	for (const child of row.children) {
-		if (child.type === "row") {
-			const found = findAttributedNodeInRow(child, id);
-			if (found) return found;
-			continue;
-		}
-		if (child.id === id) return child;
-		const tab = child.children.find((candidate) => candidate.id === id);
-		if (tab) return tab;
-	}
+	const found = locate(row, id)?.node;
+	return found?.type === "row" ? found : void 0;
 };
+const findAttributedNodeInRow = (row, id) => locate(row, id)?.node;
 const findAttributedNode = (model, id) => {
 	for (const root of collectRoots(model)) {
 		const found = findAttributedNodeInRow(root, id);
@@ -302,27 +378,20 @@ const findRootContaining = (model, nodeId) => {
 	for (const root of collectRoots(model)) if (findAttributedNodeInRow(root, nodeId)) return root;
 };
 const findTabsetParent = (row, tabsetId) => {
-	const index = row.children.findIndex((child) => child.type === "tabset" && child.id === tabsetId);
-	if (index !== -1) return {
-		index,
-		parent: row
-	};
-	for (const child of row.children) if (child.type === "row") {
-		const found = findTabsetParent(child, tabsetId);
-		if (found) return found;
-	}
+	const found = locate(row, tabsetId);
+	return found?.node.type === "tabset" && found.parent?.type === "row" ? {
+		index: found.index,
+		parent: found.parent
+	} : void 0;
 };
 const collectIdsInRow = (row, acc) => {
-	acc.push(row.id);
-	for (const child of row.children) if (child.type === "row") collectIdsInRow(child, acc);
-	else {
-		acc.push(child.id);
-		for (const tab of child.children) acc.push(tab.id);
-	}
+	walk(row, ({ node }) => {
+		acc.push(node.id);
+	});
 };
 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();
@@ -355,7 +424,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 = {}) => {
@@ -367,7 +437,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 = {}) => ({
@@ -382,13 +453,20 @@ const model = (layout, options = {}) => {
 		layout,
 		version: 1,
 		...options,
+		floats: options.floats ?? [],
 		global: options.global ?? {}
 	};
 	const duplicates = findDuplicateIds(built);
-	if (duplicates.length > 0) console.warn(`[dashfoo] builder produced duplicate node ids: ${duplicates.join(", ")} — pass explicit ids when reusing a component`);
+	if (duplicates.length > 0) console.warn(`[dashfoo] builder produced duplicate node ids: ${duplicates.join(", ")}. Pass explicit ids when reusing a component`);
 	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;
@@ -409,6 +487,23 @@ 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;
+		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" };
@@ -541,7 +636,8 @@ const zoneRect = (rect, location) => {
 			x: rect.x,
 			y: rect.y
 		};
-		default: return rect;
+		case "center": return rect;
+		default: return assertNever(location);
 	}
 };
 
@@ -603,35 +699,54 @@ 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);
+	return snapped ? {
+		kind: "engage",
+		sizes: snappedSizes
+	} : { kind: "clear" };
+};
+const settleSnap = (sizes, boundaryIndex, config) => {
+	const decision = decideSnap(sizes, boundaryIndex, config);
+	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;
+/**
+* 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.
+*/
+const inheritSlot = (row, survivor) => {
+	const sized = {
+		...survivor,
+		weight: row.weight,
+		...row.min === void 0 ? {} : { min: row.min },
+		...row.max === void 0 ? {} : { max: row.max }
+	};
+	if (sized.type === "row" && row.snap !== void 0) return {
+		...sized,
+		snap: row.snap
+	};
+	return sized;
 };
-const normalizeTabset = (tabset) => ({
-	...tabset,
-	selected: clampSelected(tabset.children.length, tabset.selected)
-});
 const normalizeRowChildren = (children) => {
 	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);
 			continue;
 		}
 		const grandchildren = normalizeRowChildren(child.children);
 		if (grandchildren.length === 0) continue;
 		if (grandchildren.length === 1) {
 			const only = grandchildren[0];
-			if (only !== void 0) out.push(child.weight === void 0 ? only : {
-				...only,
-				weight: child.weight
-			});
+			if (only !== void 0) out.push(inheritSlot(child, only));
 			continue;
 		}
 		out.push({
@@ -659,22 +774,22 @@ const normalizeLayout = (root) => {
 };
 const normalize = (model) => {
 	const layout = normalizeLayout(model.layout);
-	const healedFloats = [];
-	for (const float of model.floats ?? []) {
+	const floats = [];
+	for (const float of model.floats) {
 		const floatLayout = normalizeLayout(float.layout);
-		if (rowContainsTabset(floatLayout)) healedFloats.push({
+		if (rowContainsTabset(floatLayout)) floats.push({
 			...float,
 			layout: floatLayout
 		});
 	}
-	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 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;
 	return {
@@ -686,50 +801,40 @@ const normalize = (model) => {
 
 //#endregion
 //#region src/state/surgery.ts
-const removeTabset = (row, tabsetId) => {
-	const index = row.children.findIndex((child) => child.type === "tabset" && child.id === tabsetId);
-	if (index !== -1) {
-		row.children.splice(index, 1);
-		return true;
-	}
-	for (const child of row.children) if (child.type === "row" && removeTabset(child, tabsetId)) return true;
-	return false;
-};
 const removeTabsetReturning = (row, tabsetId) => {
-	const index = row.children.findIndex((child) => child.type === "tabset" && child.id === tabsetId);
-	if (index !== -1) {
-		const [removed] = row.children.splice(index, 1);
-		return removed?.type === "tabset" ? removed : void 0;
-	}
-	for (const child of row.children) if (child.type === "row") {
-		const found = removeTabsetReturning(child, tabsetId);
-		if (found) return found;
-	}
+	const found = findTabsetParent(row, 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"
+	};
 };
-const splitOrientation = (location) => location === "split-left" || location === "split-right" ? "row" : "column";
-const splitsBefore = (location) => location === "split-left" || location === "split-top";
 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 { before, orientation } = splitPlacement(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;
@@ -739,39 +844,54 @@ const insertTab = (draft, tab, target) => {
 	const targetTabset = findTabset(draft, targetId);
 	if (!targetTabset) return;
 	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;
 	}
-	placeBesideTarget(draft, {
+	const newTabset = {
 		children: [tab],
 		id: createNodeId("tabset"),
 		selected: 0,
 		type: "tabset",
-		weight: 50
-	}, targetId, location);
+		weight: 1
+	};
+	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.
+*/
+const detachTab = (container, index) => {
+	const removed = container.children.splice(index, 1).at(0);
+	container.selected = clampSelected(container.children.length, container.selected);
+	return removed;
 };
-const tabsetsInRow = (row, acc) => {
-	for (const child of row.children) if (child.type === "tabset") acc.push(child);
-	else tabsetsInRow(child, acc);
+const mergeTabsInto = (target, tabs, selectedOffset) => {
+	const mergeStart = target.children.length;
+	target.children.push(...tabs);
+	target.selected = mergeStart + selectedOffset;
 };
 const wrapTabInLayout = (tab) => ({
 	children: [{
 		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
@@ -794,13 +914,13 @@ 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 = [];
-	tabsetsInRow(layout, tabsets);
-	const first = tabsets[0];
+	collectTabsetsInRow(layout, tabsets);
+	const first = tabsets.at(0);
 	if (first) draft.activeTabsetId = first.id;
 };
 const floatTabsetById = (draft, tabsetId, geometry, floatId) => {
@@ -811,8 +931,8 @@ const floatTabsetById = (draft, tabsetId, geometry, floatId) => {
 };
 const resolveMainTarget = (draft, targetId) => {
 	const mainTabsets = [];
-	tabsetsInRow(draft.layout, mainTabsets);
-	if (targetId) {
+	collectTabsetsInRow(draft.layout, mainTabsets);
+	if (targetId !== void 0) {
 		const explicit = mainTabsets.find((tabset) => tabset.id === targetId);
 		if (explicit) return explicit;
 	}
@@ -823,18 +943,17 @@ const resolveMainTarget = (draft, targetId) => {
 	return mainTabsets[0];
 };
 const dockFloat = (draft, floatId, targetId, location) => {
-	const floats = draft.floats ?? [];
+	const floats = draft.floats;
 	const index = floats.findIndex((float) => float.id === floatId);
 	if (index === -1) return;
-	const [float] = floats.splice(index, 1);
-	draft.floats = floats;
+	const float = floats.splice(index, 1).at(0);
 	if (!float) return;
 	const tabsets = [];
-	tabsetsInRow(float.layout, tabsets);
+	collectTabsetsInRow(float.layout, tabsets);
 	const tabs = tabsets.flatMap((tabset) => tabset.children);
 	if (tabs.length === 0) return;
-	const leadTabset = tabsets[0];
-	const selectedOffset = leadTabset ? Math.min(Math.max(leadTabset.selected, 0), leadTabset.children.length - 1) : 0;
+	const leadTabset = tabsets.at(0);
+	const selectedOffset = leadTabset ? clampSelected(leadTabset.children.length, leadTabset.selected) : 0;
 	const target = resolveMainTarget(draft, targetId);
 	if (!target) {
 		draft.layout = float.layout;
@@ -842,27 +961,35 @@ const dockFloat = (draft, floatId, targetId, location) => {
 		return;
 	}
 	if (location === "center") {
-		const mergeStart = target.children.length;
-		target.children.push(...tabs);
-		target.selected = mergeStart + selectedOffset;
+		mergeTabsInto(target, tabs, selectedOffset);
 		draft.activeTabsetId = target.id;
 		return;
 	}
 	const where = location ?? "split-right";
-	const placed = tabsets.length === 1 && leadTabset ? leadTabset : {
+	placeBesideTarget(draft, tabsets.length === 1 && leadTabset ? leadTabset : {
 		children: tabs,
 		id: createNodeId("tabset"),
 		selected: selectedOffset,
-		type: "tabset"
-	};
-	placed.weight = 50;
-	placeBesideTarget(draft, placed, target.id, where);
+		type: "tabset",
+		weight: 1
+	}, target.id, where);
 };
 
 //#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 applyAction = (draft, action) => {
 	switch (action.type) {
@@ -877,7 +1004,7 @@ const applyAction = (draft, action) => {
 			const row = findRow(findRootContaining(draft, action.rowId) ?? draft.layout, action.rowId);
 			if (!row) return;
 			for (let index = 0; index < action.weights.length; index++) {
-				const child = row.children[index];
+				const child = row.children.at(index);
 				const weight = action.weights[index];
 				if (!child || weight === void 0) continue;
 				child.weight = weight;
@@ -886,7 +1013,7 @@ const applyAction = (draft, action) => {
 		}
 		case "deleteTab": {
 			const location = findTab(draft, action.tabId);
-			if (location) location.container.children.splice(location.index, 1);
+			if (location) detachTab(location.container, location.index);
 			return;
 		}
 		case "deleteTabset": {
@@ -900,7 +1027,7 @@ const applyAction = (draft, action) => {
 		case "floatTab": {
 			const location = findTab(draft, action.tabId);
 			if (!location) return;
-			const [removed] = location.container.children.splice(location.index, 1);
+			const removed = detachTab(location.container, location.index);
 			if (removed) pushFloat(draft, wrapTabInLayout(removed), action.geometry, action.floatId);
 			return;
 		}
@@ -915,7 +1042,7 @@ const applyAction = (draft, action) => {
 		case "moveNode": {
 			const source = findTab(draft, action.sourceId);
 			if (!source) return;
-			const [removed] = source.container.children.splice(source.index, 1);
+			const removed = detachTab(source.container, source.index);
 			if (!removed) return;
 			insertTab(draft, removed, {
 				id: action.targetId,
@@ -931,26 +1058,21 @@ const applyAction = (draft, action) => {
 			if (action.location === "center") {
 				const target = findTabset(draft, action.targetId);
 				if (target) {
-					const mergeStart = target.children.length;
-					const sourceSelected = Math.min(Math.max(source.selected, 0), source.children.length - 1);
-					target.children.push(...source.children);
-					target.selected = mergeStart + sourceSelected;
+					mergeTabsInto(target, source.children, clampSelected(source.children.length, source.selected));
 					const sourceRoot = findRootContaining(draft, action.sourceId);
 					if (sourceRoot) removeTabset(sourceRoot, action.sourceId);
 				}
 				return;
 			}
-			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);
-			}
+			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;
 		}
 		case "renameFloat": {
 			const float = findFloat(draft, action.floatId);
 			if (float) {
-				const others = (draft.floats ?? []).filter((other) => other.id !== action.floatId);
+				const others = draft.floats.filter((other) => other.id !== action.floatId);
 				float.name = uniqueFloatName(action.name, others);
 			}
 			return;
@@ -962,7 +1084,7 @@ const applyAction = (draft, action) => {
 		}
 		case "selectTab": {
 			const tabset = findTabset(draft, action.tabsetId);
-			if (tabset) tabset.selected = action.index;
+			if (tabset) tabset.selected = clampSelected(tabset.children.length, action.index);
 			return;
 		}
 		case "setActiveTabset":
@@ -981,7 +1103,7 @@ const applyAction = (draft, action) => {
 			return;
 		case "updateNodeAttributes": {
 			const node = findAttributedNode(draft, action.nodeId);
-			if (node) Object.assign(node, action.attrs);
+			if (node) Object.assign(node, parseNodeAttrs(node, action.attrs));
 			return;
 		}
 		default: assertNever(action);
@@ -1139,12 +1261,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, 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 };
 //# sourceMappingURL=index.js.map