@dashfoo/core 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,2 +1,1150 @@
-import{z as e}from"zod";import{assign as t,emit as n,setup as r}from"xstate";const i=e.lazy(()=>e.union([e.string(),e.number(),e.boolean(),e.null(),e.array(i),e.record(e.string(),i)])),a=e.enum([`top`,`bottom`,`left`,`right`]),o=e.enum([`px`,`%`,`em`,`rem`,`vh`,`vw`]),s=e.enum([`row`,`column`]),c=e.object({unit:o,value:e.number()}),l=e.object({divisions:e.union([e.number().positive(),e.literal(`panels`)]).optional(),step:e.number().min(0).optional(),threshold:e.number().positive().optional()}),u=e.object({component:e.string(),config:i.optional(),enableClose:e.boolean().optional(),enableDrag:e.boolean().optional(),enableRename:e.boolean().optional(),id:e.string(),name:e.string(),type:e.literal(`tab`)}),d=e.object({children:e.array(u),enableClose:e.boolean().optional(),enableMaximize:e.boolean().optional(),id:e.string(),max:c.optional(),min:c.optional(),name:e.string().optional(),selected:e.number().int(),type:e.literal(`tabset`),weight:e.number().optional()}),f=e.lazy(()=>e.object({children:e.array(e.union([f,d])),id:e.string(),max:c.optional(),min:c.optional(),orientation:s,snap:l.optional(),type:e.literal(`row`),weight:e.number().optional()})),p=e.object({enableSplitDock:e.boolean().optional(),enableSplitResize:e.boolean().optional(),snap:l.optional(),splitterSize:e.number().optional(),tabEnableClose:e.boolean().optional(),tabEnableDrag:e.boolean().optional(),tabEnableRename:e.boolean().optional(),tabLocation:e.enum([`top`,`bottom`]).optional(),tabSetEnableMaximize:e.boolean().optional(),tabSetEnableTabStrip:e.boolean().optional(),tabSetMinSize:e.number().optional()}),m=e.object({activeTabsetId:e.string().optional(),global:p,layout:f,maximizedTabsetId:e.string().optional(),version:e.literal(1)}),h=u.pick({config:!0,enableClose:!0,enableDrag:!0,enableRename:!0,name:!0}).partial(),g=d.pick({enableClose:!0,enableMaximize:!0,max:!0,min:!0,selected:!0,weight:!0}).partial(),ee=e.object({max:c.optional(),min:c.optional(),orientation:s,snap:l.optional(),weight:e.number()}).partial(),_=e.union([h,g,ee]),v=e.enum([`center`,`split-bottom`,`split-left`,`split-right`,`split-top`]),y=e.discriminatedUnion(`type`,[e.object({index:e.number().int().optional(),location:v,tab:u,targetId:e.string(),type:e.literal(`addNode`)}),e.object({index:e.number().int().optional(),location:v,sourceId:e.string(),targetId:e.string(),type:e.literal(`moveNode`)}),e.object({index:e.number().int().optional(),location:v,sourceId:e.string(),targetId:e.string(),type:e.literal(`moveTabset`)}),e.object({index:e.number().int(),tabsetId:e.string(),type:e.literal(`selectTab`)}),e.object({tabsetId:e.string(),type:e.literal(`setActiveTabset`)}),e.object({tabsetId:e.string().nullable(),type:e.literal(`setMaximizedTabset`)}),e.object({name:e.string(),tabId:e.string(),type:e.literal(`renameTab`)}),e.object({tabId:e.string(),type:e.literal(`deleteTab`)}),e.object({tabsetId:e.string(),type:e.literal(`deleteTabset`)}),e.object({rowId:e.string(),type:e.literal(`adjustSplit`),weights:e.array(e.number())}),e.object({attrs:_,nodeId:e.string(),type:e.literal(`updateNodeAttributes`)}),e.object({attrs:p.partial(),type:e.literal(`updateGlobalAttributes`)})]),b=(e=`node`)=>`${e}-${crypto.randomUUID()}`,te=()=>b(`tab`),x=(e,t)=>{for(let n of e.children)n.type===`tabset`?t.push(n):x(n,t)},S=e=>{let t=[];return x(e.layout,t),t},ne=e=>S(e)[0],C=(e,t)=>S(e).find(e=>e.id===t),re=(e,t)=>{let n=e.children.findIndex(e=>e.id===t);if(n===-1)return;let r=e.children[n];if(r)return{container:e,index:n,tab:r}},w=(e,t)=>{for(let n of S(e)){let e=re(n,t);if(e)return e}},T=(e,t)=>{if(e.id===t)return e;for(let n of e.children)if(n.type===`row`){let e=T(n,t);if(e)return e}},E=(e,t)=>{if(e.id===t)return e;for(let n of e.children){if(n.type===`row`){let e=E(n,t);if(e)return e;continue}if(n.id===t)return n;let e=n.children.find(e=>e.id===t);if(e)return e}},D=(e,t)=>E(e.layout,t),O=(e,t)=>{let n=e.children.findIndex(e=>e.type===`tabset`&&e.id===t);if(n!==-1)return{index:n,parent:e};for(let n of e.children)if(n.type===`row`){let e=O(n,t);if(e)return e}},k=(e,t)=>{t.push(e.id);for(let n of e.children)if(n.type===`row`)k(n,t);else{t.push(n.id);for(let e of n.children)t.push(e.id)}},A=e=>{let t=[];k(e.layout,t);let n=new Set,r=new Set;for(let e of t)n.has(e)&&r.add(e),n.add(e);return[...r]},j=e=>typeof e==`number`?{unit:`px`,value:e}:e,M=(e,t,n={})=>({component:e,name:t,type:`tab`,...n,id:n.id??e}),ie=(e,t={})=>{let{max:n,min:r,...i}=t;return{children:e,type:`tabset`,...i,...n===void 0?{}:{max:j(n)},...r===void 0?{}:{min:j(r)},id:t.id??b(`tabset`),selected:t.selected??0}},ae=(e,t={})=>{let{max:n,min:r,...i}=t;return{children:e,type:`row`,...i,...n===void 0?{}:{max:j(n)},...r===void 0?{}:{min:j(r)},id:t.id??b(`row`),orientation:t.orientation??`row`}},oe=(e,t={})=>{let n={layout:e,version:1,...t,global:t.global??{}},r=A(n);return r.length>0&&console.warn(`[dashfoo] builder produced duplicate node ids: ${r.join(`, `)} — pass explicit ids when reusing a component`),n},N=.22,se=(e,t)=>{let n=(e.x-t.x)/t.width,r=(e.y-t.y)/t.height;return{bottom:1-r,left:n,right:1-n,top:r}},ce=e=>{let t=Math.min(e.left,e.right,e.top,e.bottom);return t===e.left?`left`:t===e.right?`right`:t===e.top?`top`:`bottom`},le=(e,t,n)=>{let r=n?.bandFraction??N;if(t.width<=0||t.height<=0)return{kind:`tab`};let i=se(e,t);return Math.min(i.left,i.right,i.top,i.bottom)>r?{kind:`tab`}:{edge:ce(i),kind:`split`}},ue=(e,t)=>{let{height:n,width:r,x:i,y:a}=e,o={x:i,y:a},s={x:i+r,y:a},c={x:i+r,y:a+n},l={x:i,y:a+n};if(r<=0||n<=0)return[{location:`center`,points:[o,s,c,l]}];let u=t?.bandFraction??N,d=u*r,f=u*n,p={x:i+d,y:a+f},m={x:i+r-d,y:a+f},h={x:i+r-d,y:a+n-f},g={x:i+d,y:a+n-f};return[{location:`center`,points:[p,m,h,g]},{location:`split-left`,points:[o,p,g,l]},{location:`split-right`,points:[s,c,h,m]},{location:`split-top`,points:[o,s,m,p]},{location:`split-bottom`,points:[l,g,h,c]}]},de=(e,t)=>{let n=e.width/2,r=e.height/2;switch(t){case`split-bottom`:return{height:r,width:e.width,x:e.x,y:e.y+r};case`split-left`:return{height:e.height,width:n,x:e.x,y:e.y};case`split-right`:return{height:e.height,width:n,x:e.x+n,y:e.y};case`split-top`:return{height:r,width:e.width,x:e.x,y:e.y};default:return e}},fe=4,P=1e6,F=(e,t)=>{if(!(t<=0))for(let n=t;n<100;n+=t){let t=Math.round(n*P)/P;t<100&&e.add(t)}},I=(e,t)=>{let n=new Set;if(e.step!==void 0&&e.step>0&&F(n,e.step),e.divisions!==void 0){let r=e.divisions===`panels`?t:e.divisions;r>=2&&F(n,100/r)}return[...n].toSorted((e,t)=>e-t)},L=e=>e!==null&&((e.step??0)>0||e.divisions===`panels`||typeof e.divisions==`number`&&e.divisions>=2),R=(e,t)=>t.reduce((t,n)=>t===void 0||Math.abs(n-e)<Math.abs(t-e)?n:t,void 0),z=(e,t,n)=>{let r=n.threshold??4,i=e[t],a=e[t+1];if(t<0||i===void 0||a===void 0)return{sizes:e,snapped:!1};let o=I(n,e.length);if(o.length===0)return{sizes:e,snapped:!1};let s=0;for(let n=0;n<=t;n++)s+=e[n]??0;let c=R(s,o);if(c===void 0||Math.abs(c-s)>r)return{sizes:e,snapped:!1};let l=c-s;if(i+l<0||a-l<0)return{sizes:e,snapped:!1};let u=[...e];return u[t]=i+l,u[t+1]=a-l,{sizes:u,snapped:!0}},B=(e,t)=>{if(e===0)return 0;let n=Number.isFinite(t)?Math.trunc(t):0;return n<0?0:n>e-1?e-1:n},V=e=>({...e,selected:B(e.children.length,e.selected)}),H=e=>{let t=[];for(let n of e){if(n.type===`tabset`){n.children.length>0&&t.push(V(n));continue}let e=H(n.children);if(e.length!==0){if(e.length===1){let r=e[0];r!==void 0&&t.push(n.weight===void 0?r:{...r,weight:n.weight});continue}t.push({...n,children:e})}}return t},pe=e=>{let t=H(e.children),n=e.orientation,r=t[0];for(;t.length===1&&r?.type===`row`;)t=r.children,n=r.orientation,r=t[0];return{...e,children:t,orientation:n}},U=e=>{let t=pe(e.layout),n={...e,layout:t},r=new Set(S(n).map(e=>e.id)),i=S(n)[0]?.id,a=e.activeTabsetId!==void 0&&r.has(e.activeTabsetId)?e.activeTabsetId:i,o=e.maximizedTabsetId!==void 0&&r.has(e.maximizedTabsetId)?e.maximizedTabsetId:void 0;return{...n,activeTabsetId:a,maximizedTabsetId:o}},me=e=>{throw Error(`Unhandled action: ${JSON.stringify(e)}`)},W=(e,t)=>{let n=e.children.findIndex(e=>e.type===`tabset`&&e.id===t);if(n!==-1)return e.children.splice(n,1),!0;for(let n of e.children)if(n.type===`row`&&W(n,t))return!0;return!1},G=(e,t)=>{let n=e.children.findIndex(e=>e.type===`tabset`&&e.id===t);if(n!==-1){let[t]=e.children.splice(n,1);return t?.type===`tabset`?t:void 0}for(let n of e.children)if(n.type===`row`){let e=G(n,t);if(e)return e}},he=e=>e===`split-left`||e===`split-right`?`row`:`column`,ge=e=>e===`split-left`||e===`split-top`,K=(e,t,n,r)=>{let i=C(e,n),a=O(e.layout,n);if(!i||!a)return;let o=he(r),s=ge(r);if(a.parent.orientation===o){let e=i.weight??100;i.weight=e/2,t.weight=e/2,a.parent.children.splice(s?a.index:a.index+1,0,t)}else{let e=i.weight;i.weight=50,t.weight=50;let n={children:s?[t,i]:[i,t],id:b(`row`),orientation:o,type:`row`};e!==void 0&&(n.weight=e),a.parent.children.splice(a.index,1,n)}e.activeTabsetId=t.id},q=(e,t,n)=>{let{id:r,index:i,location:a}=n,o=C(e,r);if(o){if(a===`center`){let e=i??o.children.length;o.children.splice(e,0,t),o.selected=e;return}K(e,{children:[t],id:b(`tabset`),selected:0,type:`tabset`,weight:50},r,a)}},_e=(e,t)=>{switch(t.type){case`addNode`:q(e,t.tab,{id:t.targetId,index:t.index,location:t.location});return;case`adjustSplit`:{let n=T(e.layout,t.rowId);if(!n)return;for(let e=0;e<t.weights.length;e++){let r=n.children[e],i=t.weights[e];!r||i===void 0||(r.weight=i)}return}case`deleteTab`:{let n=w(e,t.tabId);n&&n.container.children.splice(n.index,1);return}case`deleteTabset`:W(e.layout,t.tabsetId);return;case`moveNode`:{let n=w(e,t.sourceId);if(!n)return;let[r]=n.container.children.splice(n.index,1);if(!r)return;q(e,r,{id:t.targetId,index:t.index,location:t.location});return}case`moveTabset`:{if(t.sourceId===t.targetId)return;let n=C(e,t.sourceId);if(!n)return;if(t.location===`center`){let r=C(e,t.targetId);if(r){let i=r.children.length,a=Math.min(Math.max(n.selected,0),n.children.length-1);r.children.push(...n.children),r.selected=i+a,W(e.layout,t.sourceId)}return}if(t.location.startsWith(`split-`)){let n=G(e.layout,t.sourceId);n&&K(e,n,t.targetId,t.location)}return}case`renameTab`:{let n=w(e,t.tabId);n&&(n.tab.name=t.name);return}case`selectTab`:{let n=C(e,t.tabsetId);n&&(n.selected=t.index);return}case`setActiveTabset`:C(e,t.tabsetId)&&(e.activeTabsetId=t.tabsetId);return;case`setMaximizedTabset`:e.maximizedTabsetId=t.tabsetId??void 0;return;case`updateGlobalAttributes`:Object.assign(e.global,t.attrs);return;case`updateNodeAttributes`:{let n=D(e,t.nodeId);n&&Object.assign(n,t.attrs);return}default:me(t)}},J=(e,t)=>{let n=structuredClone(e);return _e(n,t),U(n)},ve=100,Y=e=>({future:[],past:[],present:e}),ye=e=>e.past.length>0,be=e=>e.future.length>0,X=(e,t)=>{let n=J(e.present,t);return{future:[],past:[...e.past,e.present].slice(-100),present:n}},Z=e=>{let t=e.past.at(-1);return t===void 0?e:{future:[e.present,...e.future],past:e.past.slice(0,-1),present:t}},Q=e=>{let[t,...n]=e.future;return t===void 0?e:{future:n,past:[...e.past,e.present].slice(-100),present:t}},xe=r({types:{context:{},events:{},input:{}}}).createMachine({context:({input:e})=>({history:Y(e.model)}),id:`dashfoo`,initial:`ready`,states:{ready:{on:{DISPATCH:{actions:t({history:({context:e,event:t})=>X(e.history,t.action)})},REDO:{actions:t({history:({context:e})=>Q(e.history)})},SET_MODEL:{actions:t({history:({event:e})=>Y(e.model)})},UNDO:{actions:t({history:({context:e})=>Z(e.history)})}}}}}),Se=e=>{if(e.subject===null||e.intent===null)throw Error(`drop requires a subject and a drop intent`);return{intent:e.intent,subject:e.subject}},Ce=r({guards:{hasValidDrop:({context:e})=>e.subject!==null&&e.intent!==null},types:{context:{},emitted:{},events:{}}}).createMachine({context:{intent:null,subject:null},id:`dragDock`,initial:`idle`,states:{dragging:{on:{CANCEL:{target:`idle`},DROP:[{actions:n(({context:e})=>{let{intent:t,subject:n}=Se(e);return{action:n.kind===`external`?{index:t.index,location:t.location,tab:n.tab,targetId:t.targetId,type:`addNode`}:{index:t.index,location:t.location,sourceId:n.id,targetId:t.targetId,type:n.kind===`tabset`?`moveTabset`:`moveNode`},type:`COMMIT`}}),guard:`hasValidDrop`,target:`idle`},{target:`idle`}],OVER:{actions:t({intent:({event:e})=>e.intent})}}},idle:{entry:t({intent:null,subject:null}),on:{START:{actions:t({subject:({event:e})=>e.subject}),target:`dragging`}}}}}),$=e=>{let t=U(m.parse(e)),n=A(t);return n.length>0&&console.warn(`[dashfoo] duplicate node ids in the loaded layout: ${n.join(`, `)}`),t},we=e=>JSON.stringify(e),Te=e=>$(JSON.parse(e)),Ee=(e,t=`column`)=>{let n=[];for(let t of S(e))n.push({...t,weight:1});return U({...e,layout:{children:n,id:e.layout.id,orientation:t,type:`row`},maximizedTabsetId:void 0})};export{fe as DEFAULT_SNAP_THRESHOLD,ve as HISTORY_LIMIT,y as actionSchema,be as canRedo,ye as canUndo,S as collectTabsets,Y as createHistory,b as createNodeId,te as createTabId,xe as dashfooMachine,m as dashfooSchema,c as dimensionSchema,X as dispatch,v as dockLocationSchema,ue as dockZonePolygons,Ce as dragDockMachine,a as edgeSchema,D as findAttributedNode,A as findDuplicateIds,T as findRow,w as findTab,C as findTabset,O as findTabsetParent,Te as fromJSON,ne as getFirstTabset,p as globalAttributesSchema,i as jsonValueSchema,oe as model,_ as mutableNodeAttrsSchema,U as normalize,s as orientationSchema,$ as parseModel,Q as redo,J as reducer,le as resolveDockTarget,I as resolveSnapTargets,ae as row,f as rowNodeSchema,L as snapEnabled,l as snapSchema,z as snapSizes,Ee as stackModel,M as tab,u as tabNodeSchema,ie as tabset,d as tabsetNodeSchema,we as toJSON,Z as undo,o as unitSchema,de as zoneRect};
+import { z } from "zod";
+import { assign, emit, setup } from "xstate";
+
+//#region src/model/schema.ts
+const jsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(jsonValueSchema),
+	z.record(z.string(), jsonValueSchema)
+]));
+const edgeSchema = z.enum([
+	"top",
+	"bottom",
+	"left",
+	"right"
+]);
+const unitSchema = z.enum([
+	"px",
+	"%",
+	"em",
+	"rem",
+	"vh",
+	"vw"
+]);
+const orientationSchema = z.enum(["row", "column"]);
+const dimensionSchema = z.object({
+	unit: unitSchema,
+	value: z.number()
+});
+const snapSchema = z.object({
+	divisions: z.union([z.number().positive(), z.literal("panels")]).optional(),
+	step: z.number().min(0).optional(),
+	threshold: z.number().positive().optional()
+});
+const tabNodeSchema = z.object({
+	component: z.string(),
+	config: jsonValueSchema.optional(),
+	enableClose: z.boolean().optional(),
+	enableDrag: z.boolean().optional(),
+	enableRename: z.boolean().optional(),
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("tab")
+});
+const tabsetNodeSchema = z.object({
+	children: z.array(tabNodeSchema),
+	enableClose: z.boolean().optional(),
+	enableMaximize: z.boolean().optional(),
+	id: z.string(),
+	max: dimensionSchema.optional(),
+	min: dimensionSchema.optional(),
+	name: z.string().optional(),
+	selected: z.number().int(),
+	type: z.literal("tabset"),
+	weight: z.number().optional()
+});
+const rowNodeSchema = z.lazy(() => z.object({
+	children: 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()
+}));
+const geometrySchema = z.object({
+	height: z.number(),
+	left: z.number(),
+	top: z.number(),
+	width: z.number()
+});
+const floatNodeSchema = z.object({
+	geometry: geometrySchema,
+	id: z.string(),
+	layout: rowNodeSchema,
+	minimized: z.boolean().optional(),
+	name: z.string().optional(),
+	type: z.literal("float")
+});
+const globalAttributesSchema = z.object({
+	enableSplitDock: z.boolean().optional(),
+	enableSplitResize: z.boolean().optional(),
+	snap: snapSchema.optional(),
+	splitterSize: z.number().optional(),
+	tabEnableClose: z.boolean().optional(),
+	tabEnableDrag: z.boolean().optional(),
+	tabEnableRename: z.boolean().optional(),
+	tabLocation: z.enum(["top", "bottom"]).optional(),
+	tabSetEnableMaximize: z.boolean().optional(),
+	tabSetEnableTabStrip: z.boolean().optional(),
+	tabSetMinSize: z.number().optional()
+});
+const dashfooSchema = z.object({
+	activeTabsetId: z.string().optional(),
+	global: globalAttributesSchema,
+	layout: rowNodeSchema,
+	maximizedTabsetId: z.string().optional(),
+	version: z.literal(1),
+	floats: z.array(floatNodeSchema).optional()
+});
+
+//#endregion
+//#region src/state/actions.ts
+const mutableTabAttrsSchema = tabNodeSchema.pick({
+	config: true,
+	enableClose: true,
+	enableDrag: true,
+	enableRename: true,
+	name: true
+}).partial();
+const mutableTabsetAttrsSchema = tabsetNodeSchema.pick({
+	enableClose: true,
+	enableMaximize: true,
+	max: true,
+	min: true,
+	selected: true,
+	weight: true
+}).partial();
+const mutableRowAttrsSchema = z.object({
+	max: dimensionSchema.optional(),
+	min: dimensionSchema.optional(),
+	orientation: orientationSchema,
+	snap: snapSchema.optional(),
+	weight: z.number()
+}).partial();
+const mutableNodeAttrsSchema = z.union([
+	mutableTabAttrsSchema,
+	mutableTabsetAttrsSchema,
+	mutableRowAttrsSchema
+]);
+const dockLocationSchema = z.enum([
+	"center",
+	"split-bottom",
+	"split-left",
+	"split-right",
+	"split-top"
+]);
+const actionSchema = z.discriminatedUnion("type", [
+	z.object({
+		index: z.number().int().optional(),
+		location: dockLocationSchema,
+		tab: tabNodeSchema,
+		targetId: z.string(),
+		type: z.literal("addNode")
+	}),
+	z.object({
+		index: z.number().int().optional(),
+		location: dockLocationSchema,
+		sourceId: z.string(),
+		targetId: z.string(),
+		type: z.literal("moveNode")
+	}),
+	z.object({
+		index: z.number().int().optional(),
+		location: dockLocationSchema,
+		sourceId: z.string(),
+		targetId: z.string(),
+		type: z.literal("moveTabset")
+	}),
+	z.object({
+		index: z.number().int(),
+		tabsetId: z.string(),
+		type: z.literal("selectTab")
+	}),
+	z.object({
+		tabsetId: z.string(),
+		type: z.literal("setActiveTabset")
+	}),
+	z.object({
+		tabsetId: z.string().nullable(),
+		type: z.literal("setMaximizedTabset")
+	}),
+	z.object({
+		name: z.string(),
+		tabId: z.string(),
+		type: z.literal("renameTab")
+	}),
+	z.object({
+		tabId: z.string(),
+		type: z.literal("deleteTab")
+	}),
+	z.object({
+		tabsetId: z.string(),
+		type: z.literal("deleteTabset")
+	}),
+	z.object({
+		rowId: z.string(),
+		type: z.literal("adjustSplit"),
+		weights: z.array(z.number())
+	}),
+	z.object({
+		attrs: mutableNodeAttrsSchema,
+		nodeId: z.string(),
+		type: z.literal("updateNodeAttributes")
+	}),
+	z.object({
+		attrs: globalAttributesSchema.partial(),
+		type: z.literal("updateGlobalAttributes")
+	}),
+	z.object({
+		floatId: z.string().optional(),
+		geometry: geometrySchema.optional(),
+		tabId: z.string(),
+		type: z.literal("floatTab")
+	}),
+	z.object({
+		floatId: z.string().optional(),
+		geometry: geometrySchema.optional(),
+		tabsetId: z.string(),
+		type: z.literal("floatTabset")
+	}),
+	z.object({
+		floatId: z.string(),
+		location: dockLocationSchema.optional(),
+		targetId: z.string().optional(),
+		type: z.literal("dockFloat")
+	}),
+	z.object({
+		floatId: z.string(),
+		geometry: geometrySchema,
+		type: z.literal("moveFloat")
+	}),
+	z.object({
+		floatId: z.string(),
+		minimized: z.boolean(),
+		type: z.literal("setFloatMinimized")
+	}),
+	z.object({
+		floatId: z.string(),
+		name: z.string(),
+		type: z.literal("renameFloat")
+	})
+]);
+
+//#endregion
+//#region src/model/ids.ts
+const createNodeId = (prefix = "node") => `${prefix}-${crypto.randomUUID()}`;
+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 collectTabsetsInRow = (row, acc) => {
+	for (const child of row.children) if (child.type === "tabset") acc.push(child);
+	else collectTabsetsInRow(child, acc);
+};
+const collectTabsets = (model) => {
+	const acc = [];
+	for (const root of collectRoots(model)) collectTabsetsInRow(root, acc);
+	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[index];
+	if (!tab) return;
+	return {
+		container,
+		index,
+		tab
+	};
+};
+const findTab = (model, tabId) => {
+	for (const tabset of collectTabsets(model)) {
+		const found = findTabInContainer(tabset, tabId);
+		if (found) return found;
+	}
+};
+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 findAttributedNode = (model, id) => {
+	for (const root of collectRoots(model)) {
+		const found = findAttributedNodeInRow(root, id);
+		if (found) return found;
+	}
+};
+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 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);
+	}
+};
+const findDuplicateIds = (model) => {
+	const ids = [];
+	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();
+	for (const id of ids) {
+		if (seen.has(id)) duplicates.add(id);
+		seen.add(id);
+	}
+	return [...duplicates];
+};
+
+//#endregion
+//#region src/model/builders.ts
+const toDimension = (value) => typeof value === "number" ? {
+	unit: "px",
+	value
+} : value;
+const tab = (component, name, options = {}) => ({
+	component,
+	name,
+	type: "tab",
+	...options,
+	id: options.id ?? component
+});
+const tabset = (children, options = {}) => {
+	const { max, min, ...rest } = options;
+	return {
+		children,
+		type: "tabset",
+		...rest,
+		...max === void 0 ? {} : { max: toDimension(max) },
+		...min === void 0 ? {} : { min: toDimension(min) },
+		id: options.id ?? createNodeId("tabset"),
+		selected: options.selected ?? 0
+	};
+};
+const row = (children, options = {}) => {
+	const { max, min, ...rest } = options;
+	return {
+		children,
+		type: "row",
+		...rest,
+		...max === void 0 ? {} : { max: toDimension(max) },
+		...min === void 0 ? {} : { min: toDimension(min) },
+		id: options.id ?? createNodeId("row"),
+		orientation: options.orientation ?? "row"
+	};
+};
+const floatNode = (layout, geometry, options = {}) => ({
+	geometry,
+	layout,
+	type: "float",
+	...options,
+	id: options.id ?? createNodeId("float")
+});
+const model = (layout, options = {}) => {
+	const built = {
+		layout,
+		version: 1,
+		...options,
+		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`);
+	return built;
+};
+
+//#endregion
+//#region src/geometry/geometry.ts
+const DEFAULT_BAND_FRACTION = .22;
+const edgeDistances = (pointer, rect) => {
+	const fx = (pointer.x - rect.x) / rect.width;
+	const fy = (pointer.y - rect.y) / rect.height;
+	return {
+		bottom: 1 - fy,
+		left: fx,
+		right: 1 - fx,
+		top: fy
+	};
+};
+const closestEdge = (d) => {
+	const min = Math.min(d.left, d.right, d.top, d.bottom);
+	if (min === d.left) return "left";
+	if (min === d.right) return "right";
+	if (min === d.top) return "top";
+	return "bottom";
+};
+const resolveDockTarget = (pointer, rect, opts) => {
+	const band = opts?.bandFraction ?? DEFAULT_BAND_FRACTION;
+	if (rect.width <= 0 || rect.height <= 0) return { kind: "tab" };
+	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"
+	};
+};
+const dockZonePolygons = (rect, opts) => {
+	const { height: h, width: w, x, y } = rect;
+	const nw = {
+		x,
+		y
+	};
+	const ne = {
+		x: x + w,
+		y
+	};
+	const se = {
+		x: x + w,
+		y: y + h
+	};
+	const sw = {
+		x,
+		y: y + h
+	};
+	if (w <= 0 || h <= 0) return [{
+		location: "center",
+		points: [
+			nw,
+			ne,
+			se,
+			sw
+		]
+	}];
+	const band = opts?.bandFraction ?? DEFAULT_BAND_FRACTION;
+	const bx = band * w;
+	const by = band * h;
+	const innerNw = {
+		x: x + bx,
+		y: y + by
+	};
+	const innerNe = {
+		x: x + w - bx,
+		y: y + by
+	};
+	const innerSe = {
+		x: x + w - bx,
+		y: y + h - by
+	};
+	const innerSw = {
+		x: x + bx,
+		y: y + h - by
+	};
+	return [
+		{
+			location: "center",
+			points: [
+				innerNw,
+				innerNe,
+				innerSe,
+				innerSw
+			]
+		},
+		{
+			location: "split-left",
+			points: [
+				nw,
+				innerNw,
+				innerSw,
+				sw
+			]
+		},
+		{
+			location: "split-right",
+			points: [
+				ne,
+				se,
+				innerSe,
+				innerNe
+			]
+		},
+		{
+			location: "split-top",
+			points: [
+				nw,
+				ne,
+				innerNe,
+				innerNw
+			]
+		},
+		{
+			location: "split-bottom",
+			points: [
+				sw,
+				innerSw,
+				innerSe,
+				se
+			]
+		}
+	];
+};
+const zoneRect = (rect, location) => {
+	const halfW = rect.width / 2;
+	const halfH = rect.height / 2;
+	switch (location) {
+		case "split-bottom": return {
+			height: halfH,
+			width: rect.width,
+			x: rect.x,
+			y: rect.y + halfH
+		};
+		case "split-left": return {
+			height: rect.height,
+			width: halfW,
+			x: rect.x,
+			y: rect.y
+		};
+		case "split-right": return {
+			height: rect.height,
+			width: halfW,
+			x: rect.x + halfW,
+			y: rect.y
+		};
+		case "split-top": return {
+			height: halfH,
+			width: rect.width,
+			x: rect.x,
+			y: rect.y
+		};
+		default: return rect;
+	}
+};
+
+//#endregion
+//#region src/geometry/snap.ts
+const DEFAULT_SNAP_THRESHOLD = 4;
+const TARGET_PRECISION = 1e6;
+const addMultiples = (targets, increment) => {
+	if (increment <= 0) return;
+	for (let position = increment; position < 100; position += increment) {
+		const rounded = Math.round(position * TARGET_PRECISION) / TARGET_PRECISION;
+		if (rounded < 100) targets.add(rounded);
+	}
+};
+const resolveSnapTargets = (config, panelCount) => {
+	const targets = /* @__PURE__ */ new Set();
+	if (config.step !== void 0 && config.step > 0) addMultiples(targets, config.step);
+	if (config.divisions !== void 0) {
+		const divisions = config.divisions === "panels" ? panelCount : config.divisions;
+		if (divisions >= 2) addMultiples(targets, 100 / divisions);
+	}
+	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 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 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 {
+		sizes,
+		snapped: false
+	};
+	let position = 0;
+	for (let index = 0; index <= boundaryIndex; index++) position += sizes[index] ?? 0;
+	const target = nearestTarget(position, targets);
+	if (target === void 0 || Math.abs(target - position) > threshold) return {
+		sizes,
+		snapped: false
+	};
+	const delta = target - position;
+	if (left + delta < 0 || right - delta < 0) return {
+		sizes,
+		snapped: false
+	};
+	const next = [...sizes];
+	next[boundaryIndex] = left + delta;
+	next[boundaryIndex + 1] = right - delta;
+	return {
+		sizes: next,
+		snapped: true
+	};
+};
+
+//#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)
+});
+const normalizeRowChildren = (children) => {
+	const out = [];
+	for (const child of children) {
+		if (child.type === "tabset") {
+			if (child.children.length > 0) out.push(normalizeTabset(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
+			});
+			continue;
+		}
+		out.push({
+			...child,
+			children: grandchildren
+		});
+	}
+	return out;
+};
+const rowContainsTabset = (row) => row.children.some((child) => child.type === "tabset" ? true : rowContainsTabset(child));
+const normalizeLayout = (root) => {
+	let children = normalizeRowChildren(root.children);
+	let orientation = root.orientation;
+	let inner = children[0];
+	while (children.length === 1 && inner?.type === "row") {
+		children = inner.children;
+		orientation = inner.orientation;
+		inner = children[0];
+	}
+	return {
+		...root,
+		children,
+		orientation
+	};
+};
+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 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;
+	return {
+		...withRoots,
+		activeTabsetId,
+		maximizedTabsetId
+	};
+};
+
+//#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 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);
+	if (found.parent.orientation === orientation) {
+		const targetWeight = targetTabset.weight ?? 100;
+		targetTabset.weight = targetWeight / 2;
+		placed.weight = targetWeight / 2;
+		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"
+		};
+		if (targetWeight !== void 0) newRow.weight = targetWeight;
+		found.parent.children.splice(found.index, 1, newRow);
+	}
+	draft.activeTabsetId = placed.id;
+};
+const insertTab = (draft, tab, target) => {
+	const { id: targetId, index, location } = target;
+	const targetTabset = findTabset(draft, targetId);
+	if (!targetTabset) return;
+	if (location === "center") {
+		const at = index ?? targetTabset.children.length;
+		targetTabset.children.splice(at, 0, tab);
+		targetTabset.selected = at;
+		return;
+	}
+	placeBesideTarget(draft, {
+		children: [tab],
+		id: createNodeId("tabset"),
+		selected: 0,
+		type: "tabset",
+		weight: 50
+	}, targetId, location);
+};
+const tabsetsInRow = (row, acc) => {
+	for (const child of row.children) if (child.type === "tabset") acc.push(child);
+	else tabsetsInRow(child, acc);
+};
+const wrapTabInLayout = (tab) => ({
+	children: [{
+		children: [tab],
+		id: createNodeId("tabset"),
+		selected: 0,
+		type: "tabset"
+	}],
+	id: createNodeId("row"),
+	orientation: "row",
+	type: "row"
+});
+const wrapTabsetInLayout = (tabset) => ({
+	children: [tabset],
+	id: createNodeId("row"),
+	orientation: "row",
+	type: "row"
+});
+
+//#endregion
+//#region src/state/floats.ts
+const DEFAULT_FLOAT_GEOMETRY = {
+	height: 360,
+	left: 80,
+	top: 80,
+	width: 480
+};
+const uniqueFloatName = (base, floats) => {
+	const used = new Set(floats.map((float) => float.name));
+	if (!used.has(base)) return base;
+	let index = 1;
+	while (used.has(`${base} ${index}`)) index += 1;
+	return `${base} ${index}`;
+};
+const pushFloat = (draft, layout, geometry, floatId) => {
+	const float = {
+		geometry: geometry ?? DEFAULT_FLOAT_GEOMETRY,
+		id: floatId ?? createNodeId("float"),
+		layout,
+		name: uniqueFloatName("Panel", draft.floats ?? []),
+		type: "float"
+	};
+	draft.floats = [...draft.floats ?? [], float];
+	const tabsets = [];
+	tabsetsInRow(layout, tabsets);
+	const first = tabsets[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 resolveMainTarget = (draft, targetId) => {
+	const mainTabsets = [];
+	tabsetsInRow(draft.layout, mainTabsets);
+	if (targetId) {
+		const explicit = mainTabsets.find((tabset) => tabset.id === targetId);
+		if (explicit) return explicit;
+	}
+	if (draft.activeTabsetId !== void 0) {
+		const active = mainTabsets.find((tabset) => tabset.id === draft.activeTabsetId);
+		if (active) return active;
+	}
+	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);
+	draft.floats = floats;
+	if (!float) return;
+	const tabsets = [];
+	tabsetsInRow(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 target = resolveMainTarget(draft, targetId);
+	if (!target) {
+		draft.layout = float.layout;
+		draft.activeTabsetId = leadTabset?.id;
+		return;
+	}
+	if (location === "center") {
+		const mergeStart = target.children.length;
+		target.children.push(...tabs);
+		target.selected = mergeStart + selectedOffset;
+		draft.activeTabsetId = target.id;
+		return;
+	}
+	const where = location ?? "split-right";
+	const placed = tabsets.length === 1 && leadTabset ? leadTabset : {
+		children: tabs,
+		id: createNodeId("tabset"),
+		selected: selectedOffset,
+		type: "tabset"
+	};
+	placed.weight = 50;
+	placeBesideTarget(draft, placed, target.id, where);
+};
+
+//#endregion
+//#region src/state/reducer.ts
+const assertNever = (value) => {
+	throw new Error(`Unhandled action: ${JSON.stringify(value)}`);
+};
+const applyAction = (draft, action) => {
+	switch (action.type) {
+		case "addNode":
+			insertTab(draft, action.tab, {
+				id: action.targetId,
+				index: action.index,
+				location: action.location
+			});
+			return;
+		case "adjustSplit": {
+			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 weight = action.weights[index];
+				if (!child || weight === void 0) continue;
+				child.weight = weight;
+			}
+			return;
+		}
+		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;
+		}
+		case "dockFloat":
+			dockFloat(draft, action.floatId, action.targetId, action.location);
+			return;
+		case "floatTab": {
+			const location = findTab(draft, action.tabId);
+			if (!location) return;
+			const [removed] = location.container.children.splice(location.index, 1);
+			if (removed) pushFloat(draft, wrapTabInLayout(removed), action.geometry, action.floatId);
+			return;
+		}
+		case "floatTabset":
+			floatTabsetById(draft, action.tabsetId, action.geometry, action.floatId);
+			return;
+		case "moveFloat": {
+			const float = findFloat(draft, action.floatId);
+			if (float) float.geometry = action.geometry;
+			return;
+		}
+		case "moveNode": {
+			const source = findTab(draft, action.sourceId);
+			if (!source) return;
+			const [removed] = source.container.children.splice(source.index, 1);
+			if (!removed) return;
+			insertTab(draft, removed, {
+				id: action.targetId,
+				index: action.index,
+				location: action.location
+			});
+			return;
+		}
+		case "moveTabset": {
+			if (action.sourceId === action.targetId) return;
+			const source = findTabset(draft, action.sourceId);
+			if (!source) return;
+			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;
+					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);
+			}
+			return;
+		}
+		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;
+		}
+		case "renameTab": {
+			const location = findTab(draft, action.tabId);
+			if (location) location.tab.name = action.name;
+			return;
+		}
+		case "selectTab": {
+			const tabset = findTabset(draft, action.tabsetId);
+			if (tabset) tabset.selected = action.index;
+			return;
+		}
+		case "setActiveTabset":
+			if (findTabset(draft, action.tabsetId)) draft.activeTabsetId = action.tabsetId;
+			return;
+		case "setFloatMinimized": {
+			const float = findFloat(draft, action.floatId);
+			if (float) float.minimized = action.minimized;
+			return;
+		}
+		case "setMaximizedTabset":
+			draft.maximizedTabsetId = action.tabsetId ?? void 0;
+			return;
+		case "updateGlobalAttributes":
+			Object.assign(draft.global, action.attrs);
+			return;
+		case "updateNodeAttributes": {
+			const node = findAttributedNode(draft, action.nodeId);
+			if (node) Object.assign(node, action.attrs);
+			return;
+		}
+		default: assertNever(action);
+	}
+};
+const reducer = (model, action) => {
+	const draft = structuredClone(model);
+	applyAction(draft, action);
+	return normalize(draft);
+};
+
+//#endregion
+//#region src/state/history.ts
+const HISTORY_LIMIT = 100;
+const createHistory = (present) => ({
+	future: [],
+	past: [],
+	present
+});
+const canUndo = (history) => history.past.length > 0;
+const canRedo = (history) => history.future.length > 0;
+const dispatch = (history, action) => {
+	const present = reducer(history.present, action);
+	return {
+		future: [],
+		past: [...history.past, history.present].slice(-100),
+		present
+	};
+};
+const undo = (history) => {
+	const previous = history.past.at(-1);
+	if (previous === void 0) return history;
+	return {
+		future: [history.present, ...history.future],
+		past: history.past.slice(0, -1),
+		present: previous
+	};
+};
+const redo = (history) => {
+	const [next, ...rest] = history.future;
+	if (next === void 0) return history;
+	return {
+		future: rest,
+		past: [...history.past, history.present].slice(-100),
+		present: next
+	};
+};
+
+//#endregion
+//#region src/machines/dashfoo-machine.ts
+const dashfooMachine = setup({ types: {
+	context: {},
+	events: {},
+	input: {}
+} }).createMachine({
+	context: ({ input }) => ({ history: createHistory(input.model) }),
+	id: "dashfoo",
+	initial: "ready",
+	states: { ready: { on: {
+		DISPATCH: { actions: assign({ history: ({ context, event }) => dispatch(context.history, event.action) }) },
+		REDO: { actions: assign({ history: ({ context }) => redo(context.history) }) },
+		SET_MODEL: { actions: assign({ history: ({ event }) => createHistory(event.model) }) },
+		UNDO: { actions: assign({ history: ({ context }) => undo(context.history) }) }
+	} } }
+});
+
+//#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");
+	return {
+		intent: context.intent,
+		subject: context.subject
+	};
+};
+const dragDockMachine = setup({
+	guards: { hasValidDrop: ({ context }) => context.subject !== null && context.intent !== null },
+	types: {
+		context: {},
+		emitted: {},
+		events: {}
+	}
+}).createMachine({
+	context: {
+		intent: null,
+		subject: null
+	},
+	id: "dragDock",
+	initial: "idle",
+	states: {
+		dragging: { on: {
+			CANCEL: { target: "idle" },
+			DROP: [{
+				actions: emit(({ context }) => {
+					const { intent, subject } = requireDrop(context);
+					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"
+						},
+						type: "COMMIT"
+					};
+				}),
+				guard: "hasValidDrop",
+				target: "idle"
+			}, { target: "idle" }],
+			OVER: { actions: assign({ intent: ({ event }) => event.intent }) }
+		} },
+		idle: {
+			entry: assign({
+				intent: null,
+				subject: null
+			}),
+			on: { START: {
+				actions: assign({ subject: ({ event }) => event.subject }),
+				target: "dragging"
+			} }
+		}
+	}
+});
+
+//#endregion
+//#region src/model/serialize.ts
+const parseModel = (value) => {
+	const model = normalize(dashfooSchema.parse(value));
+	const duplicates = findDuplicateIds(model);
+	if (duplicates.length > 0) console.warn(`[dashfoo] duplicate node ids in the loaded layout: ${duplicates.join(", ")}`);
+	return model;
+};
+const toJSON = (model) => JSON.stringify(model);
+const fromJSON = (json) => parseModel(JSON.parse(json));
+
+//#endregion
+//#region src/model/stack.ts
+const stackModel = (model, orientation = "column") => {
+	const mainTabsets = [];
+	collectTabsetsInRow(model.layout, mainTabsets);
+	const children = [];
+	for (const tabset of mainTabsets) children.push({
+		...tabset,
+		weight: 1
+	});
+	return normalize({
+		...model,
+		layout: {
+			children,
+			id: model.layout.id,
+			orientation,
+			type: "row"
+		},
+		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 };
 //# sourceMappingURL=index.js.map