@dashfoo/core 0.5.0 → 0.5.2

package/dist/index.js

@@ -1,2 +1,1175 @@
-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({height:e.number(),left:e.number(),top:e.number(),width:e.number()}),m=e.object({geometry:p,id:e.string(),layout:f,minimized:e.boolean().optional(),name:e.string().optional(),type:e.literal(`float`)}),h=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()}),g=e.object({activeTabsetId:e.string().optional(),global:h,layout:f,maximizedTabsetId:e.string().optional(),version:e.literal(1),floats:e.array(m).optional()}),ee=u.pick({config:!0,enableClose:!0,enableDrag:!0,enableRename:!0,name:!0}).partial(),te=d.pick({enableClose:!0,enableMaximize:!0,max:!0,min:!0,selected:!0,weight:!0}).partial(),ne=e.object({max:c.optional(),min:c.optional(),orientation:s,snap:l.optional(),weight:e.number()}).partial(),_=e.union([ee,te,ne]),v=e.enum([`center`,`split-bottom`,`split-left`,`split-right`,`split-top`]),re=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:h.partial(),type:e.literal(`updateGlobalAttributes`)}),e.object({floatId:e.string().optional(),geometry:p.optional(),tabId:e.string(),type:e.literal(`floatTab`)}),e.object({floatId:e.string().optional(),geometry:p.optional(),tabsetId:e.string(),type:e.literal(`floatTabset`)}),e.object({floatId:e.string(),location:v.optional(),targetId:e.string().optional(),type:e.literal(`dockFloat`)}),e.object({floatId:e.string(),geometry:p,type:e.literal(`moveFloat`)}),e.object({floatId:e.string(),minimized:e.boolean(),type:e.literal(`setFloatMinimized`)}),e.object({floatId:e.string(),name:e.string(),type:e.literal(`renameFloat`)})]),y=(e=`node`)=>`${e}-${crypto.randomUUID()}`,ie=()=>y(`tab`),b=e=>[e.layout,...(e.floats??[]).map(e=>e.layout)],x=(e,t)=>(e.floats??[]).find(e=>e.id===t),S=(e,t)=>{for(let n of e.children)n.type===`tabset`?t.push(n):S(n,t)},C=e=>{let t=[];for(let n of b(e))S(n,t);return t},ae=e=>C(e)[0],w=(e,t)=>C(e).find(e=>e.id===t),oe=(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}},T=(e,t)=>{for(let n of C(e)){let e=oe(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}},D=(e,t)=>{if(e.id===t)return e;for(let n of e.children){if(n.type===`row`){let e=D(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}},O=(e,t)=>{for(let n of b(e)){let e=D(n,t);if(e)return e}},k=(e,t)=>{for(let n of b(e))if(D(n,t))return n},A=(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=A(n,t);if(e)return e}},se=(e,t)=>{t.push(e.id);for(let n of e.children)if(n.type===`row`)se(n,t);else{t.push(n.id);for(let e of n.children)t.push(e.id)}},j=e=>{let t=[];for(let n of e.floats??[])t.push(n.id);for(let n of b(e))se(n,t);let n=new Set,r=new Set;for(let e of t)n.has(e)&&r.add(e),n.add(e);return[...r]},M=e=>typeof e==`number`?{unit:`px`,value:e}:e,ce=(e,t,n={})=>({component:e,name:t,type:`tab`,...n,id:n.id??e}),le=(e,t={})=>{let{max:n,min:r,...i}=t;return{children:e,type:`tabset`,...i,...n===void 0?{}:{max:M(n)},...r===void 0?{}:{min:M(r)},id:t.id??y(`tabset`),selected:t.selected??0}},ue=(e,t={})=>{let{max:n,min:r,...i}=t;return{children:e,type:`row`,...i,...n===void 0?{}:{max:M(n)},...r===void 0?{}:{min:M(r)},id:t.id??y(`row`),orientation:t.orientation??`row`}},de=(e,t,n={})=>({geometry:t,layout:e,type:`float`,...n,id:n.id??y(`float`)}),fe=(e,t={})=>{let n={layout:e,version:1,...t,global:t.global??{}},r=j(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,pe=(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}},me=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`},he=(e,t,n)=>{let r=n?.bandFraction??N;if(t.width<=0||t.height<=0)return{kind:`tab`};let i=pe(e,t);return Math.min(i.left,i.right,i.top,i.bottom)>r?{kind:`tab`}:{edge:me(i),kind:`split`}},ge=(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]}]},_e=(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}},ve=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)},ye=e=>e!==null&&((e.step??0)>0||e.divisions===`panels`||typeof e.divisions==`number`&&e.divisions>=2),be=(e,t)=>t.reduce((t,n)=>t===void 0||Math.abs(n-e)<Math.abs(t-e)?n:t,void 0),xe=(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=be(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}},Se=(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},Ce=e=>({...e,selected:Se(e.children.length,e.selected)}),L=e=>{let t=[];for(let n of e){if(n.type===`tabset`){n.children.length>0&&t.push(Ce(n));continue}let e=L(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},R=e=>e.children.some(e=>e.type===`tabset`?!0:R(e)),z=e=>{let t=L(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}},B=e=>{let t=z(e.layout),n=[];for(let t of e.floats??[]){let e=z(t.layout);R(e)&&n.push({...t,layout:e})}let r=n.length>0?n:void 0,i={...e,floats:r,layout:t},a=new Set(C(i).map(e=>e.id)),o=C(i)[0]?.id,s=e.activeTabsetId!==void 0&&a.has(e.activeTabsetId)?e.activeTabsetId:o,c=e.maximizedTabsetId!==void 0&&a.has(e.maximizedTabsetId)?e.maximizedTabsetId:void 0;return{...i,activeTabsetId:s,maximizedTabsetId:c}},V=(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`&&V(n,t))return!0;return!1},H=(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=H(n,t);if(e)return e}},we=e=>e===`split-left`||e===`split-right`?`row`:`column`,Te=e=>e===`split-left`||e===`split-top`,U=(e,t,n,r)=>{let i=w(e,n),a=A(k(e,n)??e.layout,n);if(!i||!a)return;let o=we(r),s=Te(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:y(`row`),orientation:o,type:`row`};e!==void 0&&(n.weight=e),a.parent.children.splice(a.index,1,n)}e.activeTabsetId=t.id},W=(e,t,n)=>{let{id:r,index:i,location:a}=n,o=w(e,r);if(o){if(a===`center`){let e=i??o.children.length;o.children.splice(e,0,t),o.selected=e;return}U(e,{children:[t],id:y(`tabset`),selected:0,type:`tabset`,weight:50},r,a)}},G=(e,t)=>{for(let n of e.children)n.type===`tabset`?t.push(n):G(n,t)},Ee=e=>({children:[{children:[e],id:y(`tabset`),selected:0,type:`tabset`}],id:y(`row`),orientation:`row`,type:`row`}),De=e=>({children:[e],id:y(`row`),orientation:`row`,type:`row`}),Oe={height:360,left:80,top:80,width:480},K=(e,t)=>{let n=new Set(t.map(e=>e.name));if(!n.has(e))return e;let r=1;for(;n.has(`${e} ${r}`);)r+=1;return`${e} ${r}`},q=(e,t,n,r)=>{let i={geometry:n??Oe,id:r??y(`float`),layout:t,name:K(`Panel`,e.floats??[]),type:`float`};e.floats=[...e.floats??[],i];let a=[];G(t,a);let o=a[0];o&&(e.activeTabsetId=o.id)},ke=(e,t,n,r)=>{let i=k(e,t);if(!i)return;let a=H(i,t);a&&q(e,De(a),n,r)},Ae=(e,t)=>{let n=[];if(G(e.layout,n),t){let e=n.find(e=>e.id===t);if(e)return e}if(e.activeTabsetId!==void 0){let t=n.find(t=>t.id===e.activeTabsetId);if(t)return t}return n[0]},je=(e,t,n,r)=>{let i=e.floats??[],a=i.findIndex(e=>e.id===t);if(a===-1)return;let[o]=i.splice(a,1);if(e.floats=i,!o)return;let s=[];G(o.layout,s);let c=s.flatMap(e=>e.children);if(c.length===0)return;let l=s[0],u=l?Math.min(Math.max(l.selected,0),l.children.length-1):0,d=Ae(e,n);if(!d){e.layout=o.layout,e.activeTabsetId=l?.id;return}if(r===`center`){let t=d.children.length;d.children.push(...c),d.selected=t+u,e.activeTabsetId=d.id;return}let f=r??`split-right`,p=s.length===1&&l?l:{children:c,id:y(`tabset`),selected:u,type:`tabset`};p.weight=50,U(e,p,d.id,f)},Me=e=>{throw Error(`Unhandled action: ${JSON.stringify(e)}`)},Ne=(e,t)=>{switch(t.type){case`addNode`:W(e,t.tab,{id:t.targetId,index:t.index,location:t.location});return;case`adjustSplit`:{let n=E(k(e,t.rowId)??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=T(e,t.tabId);n&&n.container.children.splice(n.index,1);return}case`deleteTabset`:{let n=k(e,t.tabsetId);n&&V(n,t.tabsetId);return}case`dockFloat`:je(e,t.floatId,t.targetId,t.location);return;case`floatTab`:{let n=T(e,t.tabId);if(!n)return;let[r]=n.container.children.splice(n.index,1);r&&q(e,Ee(r),t.geometry,t.floatId);return}case`floatTabset`:ke(e,t.tabsetId,t.geometry,t.floatId);return;case`moveFloat`:{let n=x(e,t.floatId);n&&(n.geometry=t.geometry);return}case`moveNode`:{let n=T(e,t.sourceId);if(!n)return;let[r]=n.container.children.splice(n.index,1);if(!r)return;W(e,r,{id:t.targetId,index:t.index,location:t.location});return}case`moveTabset`:{if(t.sourceId===t.targetId)return;let n=w(e,t.sourceId);if(!n)return;if(t.location===`center`){let r=w(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;let o=k(e,t.sourceId);o&&V(o,t.sourceId)}return}if(t.location.startsWith(`split-`)){let n=k(e,t.sourceId),r=n?H(n,t.sourceId):void 0;r&&U(e,r,t.targetId,t.location)}return}case`renameFloat`:{let n=x(e,t.floatId);if(n){let r=(e.floats??[]).filter(e=>e.id!==t.floatId);n.name=K(t.name,r)}return}case`renameTab`:{let n=T(e,t.tabId);n&&(n.tab.name=t.name);return}case`selectTab`:{let n=w(e,t.tabsetId);n&&(n.selected=t.index);return}case`setActiveTabset`:w(e,t.tabsetId)&&(e.activeTabsetId=t.tabsetId);return;case`setFloatMinimized`:{let n=x(e,t.floatId);n&&(n.minimized=t.minimized);return}case`setMaximizedTabset`:e.maximizedTabsetId=t.tabsetId??void 0;return;case`updateGlobalAttributes`:Object.assign(e.global,t.attrs);return;case`updateNodeAttributes`:{let n=O(e,t.nodeId);n&&Object.assign(n,t.attrs);return}default:Me(t)}},J=(e,t)=>{let n=structuredClone(e);return Ne(n,t),B(n)},Pe=100,Y=e=>({future:[],past:[],present:e}),Fe=e=>e.past.length>0,Ie=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}},Le=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)})}}}}}),Re=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}},ze=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}=Re(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=B(g.parse(e)),n=j(t);return n.length>0&&console.warn(`[dashfoo] duplicate node ids in the loaded layout: ${n.join(`, `)}`),t},Be=e=>JSON.stringify(e),Ve=e=>$(JSON.parse(e)),He=(e,t=`column`)=>{let n=[];S(e.layout,n);let r=[];for(let e of n)r.push({...e,weight:1});return B({...e,layout:{children:r,id:e.layout.id,orientation:t,type:`row`},maximizedTabsetId:void 0})};export{ve as DEFAULT_SNAP_THRESHOLD,Pe as HISTORY_LIMIT,re as actionSchema,Ie as canRedo,Fe as canUndo,b as collectRoots,C as collectTabsets,S as collectTabsetsInRow,Y as createHistory,y as createNodeId,ie as createTabId,Le as dashfooMachine,g as dashfooSchema,c as dimensionSchema,X as dispatch,v as dockLocationSchema,ge as dockZonePolygons,ze as dragDockMachine,a as edgeSchema,O as findAttributedNode,j as findDuplicateIds,x as findFloat,k as findRootContaining,E as findRow,T as findTab,w as findTabset,A as findTabsetParent,de as floatNode,m as floatNodeSchema,Ve as fromJSON,p as geometrySchema,ae as getFirstTabset,h as globalAttributesSchema,i as jsonValueSchema,fe as model,_ as mutableNodeAttrsSchema,B as normalize,s as orientationSchema,$ as parseModel,Q as redo,J as reducer,he as resolveDockTarget,I as resolveSnapTargets,ue as row,f as rowNodeSchema,ye as snapEnabled,l as snapSchema,xe as snapSizes,He as stackModel,ce as tab,u as tabNodeSchema,le as tabset,d as tabsetNodeSchema,Be as toJSON,Z as undo,o as unitSchema,_e 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(),
+	floats: z.array(floatNodeSchema).optional(),
+	global: globalAttributesSchema,
+	layout: rowNodeSchema,
+	maximizedTabsetId: z.string().optional(),
+	version: z.literal(1)
+});
+
+//#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 splitWeightsSchema = z.array(z.number());
+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: splitWeightsSchema
+	}),
+	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);
+/**
+* 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) => {
+	walk(row, ({ node }) => {
+		if (node.type === "tabset") acc.push(node);
+	});
+};
+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.at(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) => {
+	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);
+		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 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) => {
+	walk(row, ({ node }) => {
+		acc.push(node.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
+		};
+		case "center": return rect;
+		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)
+});
+/**
+* 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,
+		...row.weight === void 0 ? {} : { 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 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(inheritSlot(child, only));
+			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 removeTabsetReturning = (row, tabsetId) => {
+	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 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;
+	}
+	const newTabset = {
+		children: [tab],
+		id: createNodeId("tabset"),
+		selected: 0,
+		type: "tabset",
+		weight: 50
+	};
+	placeBesideTarget(draft, newTabset, targetId, location);
+};
+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"
+	}],
+	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 = [];
+	collectTabsetsInRow(layout, tabsets);
+	const first = tabsets.at(0);
+	if (first) draft.activeTabsetId = first.id;
+};
+const floatTabsetById = (draft, tabsetId, geometry, floatId) => {
+	const root = findRootContaining(draft, tabsetId);
+	if (!root) return;
+	const detached = removeTabsetReturning(root, tabsetId);
+	if (detached) pushFloat(draft, wrapTabsetInLayout(detached), geometry, floatId);
+};
+const resolveMainTarget = (draft, targetId) => {
+	const mainTabsets = [];
+	collectTabsetsInRow(draft.layout, mainTabsets);
+	if (targetId !== void 0) {
+		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).at(0);
+	draft.floats = floats;
+	if (!float) return;
+	const tabsets = [];
+	collectTabsetsInRow(float.layout, tabsets);
+	const tabs = tabsets.flatMap((tabset) => tabset.children);
+	if (tabs.length === 0) return;
+	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;
+		draft.activeTabsetId = leadTabset?.id;
+		return;
+	}
+	if (location === "center") {
+		mergeTabsInto(target, tabs, 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.at(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).at(0);
+			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).at(0);
+			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) {
+					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);
+			}
+			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