@canwork/boxwood 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Canwork Studios
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,213 @@
+# Boxwood
+
+[![npm version](https://img.shields.io/npm/v/@canwork/boxwood?style=for-the-badge)](https://www.npmjs.com/package/@canwork/boxwood) [![GitHub Actions](https://img.shields.io/github/actions/workflow/status/canwork/boxwood/ci.yml?branch=main&style=for-the-badge)](https://github.com/canwork/boxwood/actions/workflows/ci.yml) [![License](https://img.shields.io/npm/l/@canwork/boxwood?style=for-the-badge)](LICENSE)
+
+A Declarative Box-Split and Collision Engine for Vector Graphics. It provides a CSS-like layout grammar (`padding`, `gap`, `cols`, `rows`, `auto-height`) and resolves it into a clean JSON coordinate tree for any visual canvas (SVG, `<canvas>`, WebGL).
+
+Unlike typical layout libraries (like Yoga or standard web browsers) that hide resolved position values inside a black box, **Boxwood** exposes absolute coordinate geometry (`{x, y, w, h}`) directly. That makes it easy to draw responsive visuals, route connectors, and manage collision-safe compositions.
+
+---
+![Demo Animation](./brutalist_playground_visual_1782343082910.webp)
+
+## Quick start
+
+```bash
+npm install @canwork/boxwood
+```
+
+```ts
+import { resolveLayout, defaultMeasure, LNode } from "@canwork/boxwood";
+
+const layoutTree: LNode = {
+  style: { padding: 20 },
+  split: { cols: ["60%", "40%"], gap: 15 },
+  children: [
+    { id: "main-panel", style: { w: "100%", h: "100%" } },
+    {
+      style: { w: "100%", h: "100%" },
+      split: { rows: 2, gap: 10 },
+      children: [
+        { id: "sub-card-1", style: { padding: 12 } },
+        { id: "sub-card-2", style: { padding: 12 } },
+      ],
+    },
+  ],
+};
+
+const boundary = { x: 0, y: 0, w: 1920, h: 1080 };
+const result = resolveLayout(layoutTree, boundary, { measure: defaultMeasure });
+console.log(result.boxes);
+```
+
+### CDN (no build step)
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@canwork/boxwood/dist/boxwood.global.js"></script>
+<script>
+  const { resolveLayout, defaultMeasure } = Boxwood;
+  const result = resolveLayout(layoutTree, boundary, { measure: defaultMeasure });
+</script>
+```
+
+Or via unpkg:
+
+```html
+<script src="https://unpkg.com/@canwork/boxwood/dist/boxwood.global.js"></script>
+```
+
+## Layout flow at a glance
+
+```mermaid
+flowchart TD
+    A["LNode tree\nstyle / split / children"] --> B["resolveLayout(root, boundary, opts)"]
+    B --> C["Resolve layout rules\npadding, gap, cols, rows, grid"]
+    B --> D["Measure content\ntext wrap / overflow"]
+    C --> E["Compute contentFrame and box geometry"]
+    D --> E
+    E --> F["Resolved boxes\n{x, y, w, h}"]
+    F --> G["Render with SVG / Canvas / WebGL"]
+```
+
+```mermaid
+flowchart TB
+    R["root LNode"] --> C1["child LNode"]
+    R --> C2["child LNode"]
+    C1 --> G1["grandchild LNode"]
+    C2 --> G2["grandchild LNode"]
+    C1 --> G3["grandchild LNode"]
+    C2 --> G4["grandchild LNode"]
+    G1 --> B1["resolved box"]
+    G2 --> B2["resolved box"]
+    G3 --> B3["resolved box"]
+    G4 --> B4["resolved box"]
+```
+
+## Why Boxwood?
+
+Boxwood is designed for developers who need a declarative layout model but also need the exact coordinates to render shapes, arrows, labels, and collision-aware content.
+
+| Layout Library | Declarative Box Model | Coordinates for Lines/Arrows | Lightweight & Zero-DOM | Collision Separation |
+| :--- | :---: | :---: | :---: | :---: |
+| **Yoga / Flexbox** | ✅ Yes | ❌ No | ⚠️ Complex C++ bindings | ❌ No |
+| **D3 / Cytoscape** | ❌ No | ✅ Yes | ✅ Yes | ⚠️ Force-directed |
+| **Boxwood** | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
+
+### What Boxwood gives you
+
+- Declarative layout rules for cols, rows, grids, gap, padding, margin, and auto sizing
+- Absolute coordinate output ready for SVG, `<canvas>`, WebGL, or custom rendering
+- Nested layout composition with resolved geometry for every node
+- Text measurement and overflow-aware sizing via `measure`
+- Collision resolution so layout boxes do not overlap unexpectedly
+
+---
+
+## Demo
+
+Open `examples/interactive-demo.html` in your browser to see the engine running with a live resize demo.
+
+---
+
+## Core API & Types
+
+### 1. Defining a Layout Tree (`LNode`)
+
+Layouts are represented as a nested tree structure:
+
+```typescript
+import { LNode } from "@canwork/boxwood";
+
+const layoutTree: LNode = {
+  style: { padding: 20 },
+  split: { cols: ["60%", "40%"], gap: 15 },
+  children: [
+    {
+      id: "main-panel",
+      style: { w: "100%", h: "100%" }
+    },
+    {
+      style: { w: "100%", h: "100%" },
+      split: { rows: 2, gap: 10 },
+      children: [
+        { id: "sub-card-1", style: { padding: 12 } },
+        { id: "sub-card-2", style: { padding: 12 } }
+      ]
+    }
+  ]
+};
+```
+
+### 2. Resolving Layout Coordinates (`resolveLayout`)
+
+Run the solver on your layout tree by passing the root node and the parent boundary dimensions:
+
+```typescript
+import { resolveLayout } from "@canwork/boxwood";
+
+const boundary = { x: 0, y: 0, w: 1920, h: 1080 }; // 1080p frame
+const result = resolveLayout(layoutTree, boundary);
+
+console.log(result.boxes);
+/*
+Outputs a flat list of absolute coordinate boxes:
+[
+  { id: "main-panel", box: { x: 20, y: 20, w: 1128, h: 1040 } },
+  { id: "sub-card-1", box: { x: 1163, y: 20, w: 737, h: 515 } },
+  { id: "sub-card-2", box: { x: 1163, y: 545, w: 737, h: 515 } }
+]
+*/
+```
+
+---
+
+## Drawing Layout Connections
+
+Because **Boxwood** returns absolute coordinate values, routing arrows and lines between elements is simple:
+
+```typescript
+// Find the resolved boxes
+const boxA = result.boxes.find(b => b.node.id === "sub-card-1")?.box;
+const boxB = result.boxes.find(b => b.node.id === "sub-card-2")?.box;
+
+if (boxA && boxB) {
+  // Center coordinates of both boxes
+  const x1 = boxA.x + boxA.w / 2;
+  const y1 = boxA.y + boxA.h / 2;
+  const x2 = boxB.x + boxB.w / 2;
+  const y2 = boxB.y + boxB.h / 2;
+
+  // Render SVG or Canvas lines using these points
+  // e.g. <line x1={x1} y1={y1} x2={x2} y2={y2} stroke="gold" />
+}
+```
+
+---
+
+## Advanced Features
+
+### 1. Dynamic Text Measurements & Font Sizing
+You can pass custom measurement rules to child nodes using a `measure` hook. The engine will automatically evaluate if text fits inside a container. If text wraps or overflows, it raises a structured `OverflowSignal` in the solver result, letting you decrease font size or handle resizing programmatically.
+
+### 2. Collision Separation Solver
+When visual cards enter with scale spring animations, or dynamic data changes their sizes on the fly, Boxwood runs an overlap solver to push boxes apart, guaranteeing your nodes never overlap.
+
+---
+
+## Visual Examples & Use Cases
+
+To showcase the responsiveness and design rules of the layout solver, we built a **Google Stitch Stark Brutalist Playground** in the `examples/` directory:
+
+* **[interactive-demo.html](file:///Users/bonzai-carn/Documents/CanworkStudios/content-generator/storyboard/layout-engine/examples/interactive-demo.html)**: Open this file directly in any browser. It renders an interactive viewport with a corner drag-handle, running the layout solver in real-time as you scale or squeeze the container.
+
+Additionally, we have prepared self-contained console scripts demonstrating each use case:
+
+1. **`01-bento-grid.ts`**: Builds a dashboard-style "Bento box" grid with side-by-side splits and shows how it adapts dynamically between desktop and mobile portrait layout shapes.
+2. **`02-vector-connections.ts`**: Demonstrates horizontal pipeline layout structures, retrieving coordinate boxes, and generating Bezier path coordinates to draw custom SVG connection arrows.
+3. **`03-absolute-to-responsive.ts`**: Illustrates how to take a set of static, absolute coordinate elements (e.g. from PDF.js) and wrap them into a responsive Boxwood column grid.
+4. **`04-dynamic-reflow-overflow.ts`**: Walks through the dynamic text measurement system, showing how text wraps and shifts downstream sibling cards downwards to prevent overlap, alongside emitting overflow alerts.
+
+---
+
+## License
+
+MIT © Canwork Studios

package/dist/boxwood.global.js

@@ -0,0 +1 @@
+"use strict";var Boxwood=(()=>{var A=Object.defineProperty;var G=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var O=Object.prototype.hasOwnProperty;var X=(e,t)=>{for(var n in t)A(e,n,{get:t[n],enumerable:!0})},Y=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of I(t))!O.call(e,s)&&s!==n&&A(e,s,{get:()=>t[s],enumerable:!(o=G(t,s))||o.enumerable});return e};var Z=e=>Y(A({},"__esModule",{value:!0}),e);var re={};X(re,{defaultMeasure:()=>B,resolveColWidths:()=>w,resolveCollisions:()=>N,resolveGap:()=>L,resolveLayout:()=>j,resolveRowHeights:()=>M,resolveSides:()=>d,shrinkToFit:()=>E,splitCols:()=>g,splitGrid:()=>R,splitRows:()=>S,splitZones:()=>v});function d(e){return e===void 0?{top:0,right:0,bottom:0,left:0}:typeof e=="number"?{top:e,right:e,bottom:e,left:e}:{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function K(e,t,n){if(e===void 0||e==="auto")return n;if(typeof e=="number")return e;let o=parseFloat(e);return e.endsWith("%")&&!isNaN(o)?o/100*t:n}function L(e,t){return K(e,t,0)}function w(e,t,n){if(typeof e=="number"){let r=Math.max(1,e),h=(t-n*(r-1))/r;return Array.from({length:r},(c,x)=>({w:h,kind:"fixed",idx:x}))}let o=0,s=0,i=0;for(let r of e)typeof r=="number"?o+=r:r==="auto"?i++:r.endsWith("%")&&(s+=parseFloat(r));let l=s/100*t,f=t-o-l-n*(e.length-1),u=i>0?Math.max(0,f/i):0;return e.map((r,h)=>{if(typeof r=="number")return{w:r,kind:"fixed",idx:h};if(r==="auto")return{w:u,kind:"auto",idx:h};let c=parseFloat(r);return r.endsWith("%")&&!isNaN(c)?{w:c/100*t,kind:"pct",idx:h}:{w:0,kind:"fixed",idx:h}})}function g(e,t,n,o){let s=e.x+o.left,i=e.y+o.top,l=e.w-o.left-o.right,f=e.h-o.top-o.bottom,u=[],r=s;for(let h of t)u.push({x:r,y:i,w:h.w,h:f}),r+=h.w+n;return u}function M(e,t,n,o){if(typeof e=="number"){let c=Math.max(1,e),x=(t-n*(c-1))/c;return Array.from({length:c},(m,b)=>({h:x,kind:"fixed",idx:b}))}let s=e.length,i=0,l=0,f=e.filter(c=>c==="auto").length;for(let c=0;c<s;c++){let x=e[c];if(typeof x=="number")i+=x;else if(typeof x=="string"&&x.endsWith("%")){let m=parseFloat(x);isNaN(m)||(l+=m/100*t)}}let u=t-i-l-n*(s-1),r=o.reduce((c,x)=>c+x,0),h=0;return f>0&&(r<=u?h=r/f:h=u/f),e.map((c,x)=>{if(typeof c=="number")return{h:c,kind:"fixed",idx:x};if(c==="auto")return{h,kind:"auto",idx:x};let m=parseFloat(c);return c.endsWith("%")&&!isNaN(m)?{h:m/100*t,kind:"pct",idx:x}:{h:0,kind:"fixed",idx:x}})}function S(e,t,n,o){let s=e.x+o.left,i=e.y+o.top,l=e.w-o.left-o.right,f=e.h-o.top-o.bottom,u=[],r=i;for(let h of t)u.push({x:s,y:r,w:l,h:h.h}),r+=h.h+n;return u}function R(e,t,n,o){let[s,i]=t,l=e.x+o.left,f=e.y+o.top,u=e.w-o.left-o.right,r=e.h-o.top-o.bottom,h=(u-n*(s-1))/s,c=(r-n*(i-1))/i,x=[];for(let m=0;m<i;m++)for(let b=0;b<s;b++)x.push({x:l+b*(h+n),y:f+m*(c+n),w:h,h:c});return x}function v(e){return Object.values(e)}function k(e,t,n){if(t<=0)return e;let o=e;for(;o>14&&n(o)>t;)o-=1;return Math.max(14,o)}function W(e,t,n){if(t<=0||!e)return[e];let o=e.split(/\s+/),s=[],i="";for(let l of o){let f=i?i+" "+l:l;n(f)<=t||!i?i=f:(s.push(i),i=l)}return i&&s.push(i),s}var T=8;function q(e,t){return e.length*t*(T/14)}function B(e,t,n){let o=k(t.fontSize,n,h=>q(e,h)),s=o*(T/14),i=h=>h.length*s,l=W(e,n,i),f=o*1.2,u=o*.8,r=o*.2;return{lines:l,w:Math.min(n,Math.max(...l.map(i))),h:l.length*f,ascent:u,descent:r}}function E(e,t,n,o,s,i=14){let l=t;for(;l>=i;){let u=s(e,{fontSize:l},n);if(u.h<=o)return{fontSize:l,lines:u.lines,h:u.h};l-=1}let f=s(e,{fontSize:i},n);return{fontSize:i,lines:f.lines,h:f.h}}function H(e,t){let n=t.parent;for(;n;){if(n===e)return!0;n=n.parent}return!1}function J(e,t){return e.x<t.x+t.w&&e.x+e.w>t.x&&e.y<t.y+t.h&&e.y+e.h>t.y}function Q(e,t){let n=Math.max(0,Math.min(e.x+e.w,t.x+t.w)-Math.max(e.x,t.x)),o=Math.max(0,Math.min(e.y+e.h,t.y+t.h)-Math.max(e.y,t.y));return n*o}var P=10,$=5;function N(e,t){if(!(e.length<2)){for(let n=0;n<$;n++){let o=!1;for(let s=0;s<e.length;s++)for(let i=s+1;i<e.length;i++){let l=e[s],f=e[i];if(H(l,f)||H(f,l)||!J(l.box,f.box))continue;o=!0;let u=l.box,r=f.box,h=Q(u,r),c=Math.min(u.x+u.w,r.x+r.w)-Math.max(u.x,r.x),x=Math.min(u.y+u.h,r.y+r.h)-Math.max(u.y,r.y),m=c<x?P:0,b=c>=x?P:0;m!==0&&(u.x<r.x?r.x+=m:u.x+=m),b!==0&&(u.y<r.y?r.y+=b:u.y+=b)}if(!o)break}for(let n of e)n.box.x=Math.max(0,Math.min(n.box.x,t.w-n.box.w)),n.box.y=Math.max(0,Math.min(n.box.y,t.h-n.box.h))}}function V(e,t){return{x:e.x+t.left,y:e.y+t.top,w:Math.max(0,e.w-t.left-t.right),h:Math.max(0,e.h-t.top-t.bottom)}}function F(e,t){return{x:e.x+t.left,y:e.y+t.top,w:Math.max(0,e.w-t.left-t.right),h:Math.max(0,e.h-t.top-t.bottom)}}function C(e,t,n){if(e===void 0||e==="auto")return n;if(typeof e=="number")return e;let o=parseFloat(e);return e.endsWith("%")&&!isNaN(o)?o/100*t:n}function ee(e,t,n,o){return e==="center"?{x:t.x+(t.w-n)/2,y:t.y+(t.h-o)/2}:e===void 0?{x:t.x,y:t.y}:{x:e.x!==void 0?C(e.x,t.w,t.x):t.x,y:e.y!==void 0?C(e.y,t.h,t.y):t.y}}function _(e,t){if(t.push(e),e.children)for(let n of e.children)_(n,t)}function te(e,t){if(e===void 0||e==="auto")return{h:0,isAuto:!0};if(typeof e=="number")return{h:e,isAuto:!1};if(typeof e=="string"&&e.endsWith("%")){let n=parseFloat(e);if(!isNaN(n))return{h:n/100*t,isAuto:!1}}return{h:0,isAuto:!0}}function y(e,t,n,o,s){let i=d(e.style.margin),l=d(e.style.padding),f,u,r,h,c=te(e.style.h,t.h);if(n)f=n.w,u=n.h!==0?n.h:c.h,r=n.x,h=n.y;else{f=C(e.style.w,t.w,t.w),u=c.h;let a=ee(e.style.pos,t,f,u||t.h);r=a.x,h=a.y}let x=V({x:r,y:h,w:f,h:u},i),m=F(x,l);u===0&&!e.measure&&(x.h=t.h,m.h=Math.max(0,t.h-l.top-l.bottom));let b,p;if(e.split?b=ne(e,e.split,m,o,s):e.children&&e.children.length>0&&(b=e.children.map(a=>y(a,m,null,o,s))),e.measure&&m.w>0){let a=e.measure(m);if(p={lines:a.lines,fontSize:a.ascent?Math.round(a.ascent/.8):14,ascent:a.ascent,descent:a.descent},u===0){let D=a.h+l.top+l.bottom;x.h=Math.max(D,1),m.h=Math.max(a.h,1)}a.h>m.h&&m.h>0&&s.push({path:"",box:m,fontSize:p.fontSize,text:a.lines.join(" ")})}let z={node:e,box:{x:x.x,y:x.y,w:x.w,h:x.h},contentFrame:{x:m.x,y:m.y,w:m.w,h:m.h},textLayout:p,children:b};if(b)for(let a of b)a.parent=z;return z}function ne(e,t,n,o,s){let i=e.children;if(!i||i.length===0)return[];let l="gap"in t&&t.gap!==void 0?L(t.gap,n.w):0,f="pad"in t&&t.pad!==void 0?d(t.pad):d(void 0);if("rows"in t&&(typeof t.rows=="number"||Array.isArray(t.rows))){let u=n.w-f.left-f.right,r=[];for(let m=0;m<i.length;m++)r.push(oe(i[m],u,o.measure));let h=n.h-f.top-f.bottom,c=M(t.rows,h,l,r),x=S(n,c,l,f);return i.map((m,b)=>{let p=x[Math.min(b,x.length-1)];return y(m,n,p,o,s)})}if("cols"in t&&(typeof t.cols=="number"||Array.isArray(t.cols))){let u=n.w-f.left-f.right,r=w(t.cols,u,l),h=g(n,r,l,f);return i.map((c,x)=>{let m=h[Math.min(x,h.length-1)];return y(c,n,m,o,s)})}if("grid"in t){let u=R(n,t.grid,l,f);return i.map((r,h)=>{let c=u[Math.min(h,u.length-1)];return y(r,n,c,o,s)})}if("zones"in t){let u=v(t.zones);return i.map((r,h)=>{let c=u[Math.min(h,u.length-1)];return y(r,n,c,o,s)})}return[]}function oe(e,t,n){if(!e.measure)return e.children&&e.children.length>0?60:0;let o={x:0,y:0,w:t,h:0},s=e.measure(o),i=d(e.style.padding);return s.h+i.top+i.bottom}function j(e,t,n){let o=n?.measure??B,s=[],i=y(e,t,null,{measure:o},s),l=[];return _(i,l),N(l,t),{root:i,boxes:l,overflow:s}}return Z(re);})();

package/dist/collide.d.ts

@@ -0,0 +1,2 @@
+import type { LBox, ResolvedLNode } from "./types.js";
+export declare function resolveCollisions(resolvedNodes: ResolvedLNode[], world: LBox): void;

package/dist/collide.js

@@ -0,0 +1,62 @@
+function isAncestor(ancestor, node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur === ancestor)
+            return true;
+        cur = cur.parent;
+    }
+    return false;
+}
+function boxesOverlap(a, b) {
+    return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
+function overlapArea(a, b) {
+    const ox = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x));
+    const oy = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+    return ox * oy;
+}
+const NUDGE_DISTANCE = 10;
+const MAX_PASSES = 5;
+export function resolveCollisions(resolvedNodes, world) {
+    if (resolvedNodes.length < 2)
+        return;
+    for (let pass = 0; pass < MAX_PASSES; pass++) {
+        let anyCollision = false;
+        for (let i = 0; i < resolvedNodes.length; i++) {
+            for (let j = i + 1; j < resolvedNodes.length; j++) {
+                const ni = resolvedNodes[i];
+                const nj = resolvedNodes[j];
+                if (isAncestor(ni, nj) || isAncestor(nj, ni))
+                    continue;
+                if (!boxesOverlap(ni.box, nj.box))
+                    continue;
+                anyCollision = true;
+                const a = ni.box;
+                const b = nj.box;
+                const area = overlapArea(a, b);
+                const overlapW = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);
+                const overlapH = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);
+                const nudgeX = overlapW < overlapH ? NUDGE_DISTANCE : 0;
+                const nudgeY = overlapW >= overlapH ? NUDGE_DISTANCE : 0;
+                if (nudgeX !== 0) {
+                    if (a.x < b.x)
+                        b.x += nudgeX;
+                    else
+                        a.x += nudgeX;
+                }
+                if (nudgeY !== 0) {
+                    if (a.y < b.y)
+                        b.y += nudgeY;
+                    else
+                        a.y += nudgeY;
+                }
+            }
+        }
+        if (!anyCollision)
+            break;
+    }
+    for (const rn of resolvedNodes) {
+        rn.box.x = Math.max(0, Math.min(rn.box.x, world.w - rn.box.w));
+        rn.box.y = Math.max(0, Math.min(rn.box.y, world.h - rn.box.h));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { LBox, LStyle, LNode, Len, Sides, Pos, Split, ResolvedLNode, TextLayout, Measure, LayoutResult, OverflowSignal, } from "./types.js";
+export { resolveLayout } from "./resolve.js";
+export { defaultMeasure, shrinkToFit } from "./measure.js";
+export { resolveSides, resolveGap, resolveColWidths, resolveRowHeights, splitCols, splitRows, splitGrid, splitZones, } from "./split.js";
+export { resolveCollisions } from "./collide.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { resolveLayout } from "./resolve.js";
+export { defaultMeasure, shrinkToFit } from "./measure.js";
+export { resolveSides, resolveGap, resolveColWidths, resolveRowHeights, splitCols, splitRows, splitGrid, splitZones, } from "./split.js";
+export { resolveCollisions } from "./collide.js";

package/dist/measure.d.ts

@@ -0,0 +1,15 @@
+import type { Measure } from "./types.js";
+export declare function defaultMeasure(text: string, style: {
+    fontSize: number;
+}, maxW: number): {
+    lines: string[];
+    w: number;
+    h: number;
+    ascent: number;
+    descent: number;
+};
+export declare function shrinkToFit(text: string, fontSize: number, maxW: number, maxH: number, measurePage: Measure, floor?: number): {
+    fontSize: number;
+    lines: string[];
+    h: number;
+};

package/dist/measure.js

@@ -0,0 +1,33 @@
+import { wrapText, fitFontSize, MIN_READABLE } from "./text-fit.js";
+const FALLBACK_CHAR_WIDTH = 8;
+function estimateTextWidth(text, fontSize) {
+    return text.length * fontSize * (FALLBACK_CHAR_WIDTH / 14);
+}
+export function defaultMeasure(text, style, maxW) {
+    const size = fitFontSize(style.fontSize, maxW, (s) => estimateTextWidth(text, s));
+    const charW = size * (FALLBACK_CHAR_WIDTH / 14);
+    const measureText = (t) => t.length * charW;
+    const lines = wrapText(text, maxW, measureText);
+    const lineH = size * 1.2;
+    const ascent = size * 0.8;
+    const descent = size * 0.2;
+    return {
+        lines,
+        w: Math.min(maxW, Math.max(...lines.map(measureText))),
+        h: lines.length * lineH,
+        ascent,
+        descent,
+    };
+}
+export function shrinkToFit(text, fontSize, maxW, maxH, measurePage, floor = MIN_READABLE) {
+    let size = fontSize;
+    while (size >= floor) {
+        const m = measurePage(text, { fontSize: size }, maxW);
+        if (m.h <= maxH) {
+            return { fontSize: size, lines: m.lines, h: m.h };
+        }
+        size -= 1;
+    }
+    const m = measurePage(text, { fontSize: floor }, maxW);
+    return { fontSize: floor, lines: m.lines, h: m.h };
+}

package/dist/resolve.d.ts

@@ -0,0 +1,4 @@
+import type { LBox, LNode, Measure, LayoutResult } from "./types.js";
+export declare function resolveLayout(root: LNode, world: LBox, hooks?: {
+    measure?: Measure;
+}): LayoutResult;

package/dist/resolve.js

@@ -0,0 +1,205 @@
+import { resolveSides, resolveGap, resolveColWidths, resolveRowHeights, splitCols, splitRows, splitGrid, splitZones, } from "./split.js";
+import { defaultMeasure } from "./measure.js";
+import { resolveCollisions } from "./collide.js";
+function applyMargin(box, margin) {
+    return {
+        x: box.x + margin.left,
+        y: box.y + margin.top,
+        w: Math.max(0, box.w - margin.left - margin.right),
+        h: Math.max(0, box.h - margin.top - margin.bottom),
+    };
+}
+function applyPad(box, pad) {
+    return {
+        x: box.x + pad.left,
+        y: box.y + pad.top,
+        w: Math.max(0, box.w - pad.left - pad.right),
+        h: Math.max(0, box.h - pad.top - pad.bottom),
+    };
+}
+function resolveLen(v, parentSize, defaultVal) {
+    if (v === undefined)
+        return defaultVal;
+    if (v === "auto")
+        return defaultVal;
+    if (typeof v === "number")
+        return v;
+    const pct = parseFloat(v);
+    if (v.endsWith("%") && !isNaN(pct))
+        return (pct / 100) * parentSize;
+    return defaultVal;
+}
+function resolvePos(pos, parentFrame, nodeW, nodeH) {
+    if (pos === "center") {
+        return {
+            x: parentFrame.x + (parentFrame.w - nodeW) / 2,
+            y: parentFrame.y + (parentFrame.h - nodeH) / 2,
+        };
+    }
+    if (pos === undefined) {
+        return { x: parentFrame.x, y: parentFrame.y };
+    }
+    return {
+        x: pos.x !== undefined ? resolveLen(pos.x, parentFrame.w, parentFrame.x) : parentFrame.x,
+        y: pos.y !== undefined ? resolveLen(pos.y, parentFrame.h, parentFrame.y) : parentFrame.y,
+    };
+}
+function flattenResolved(node, out) {
+    out.push(node);
+    if (node.children) {
+        for (const c of node.children)
+            flattenResolved(c, out);
+    }
+}
+function resolveBoxHeight(styleH, parentH) {
+    if (styleH === undefined || styleH === "auto") {
+        return { h: 0, isAuto: true };
+    }
+    if (typeof styleH === "number") {
+        return { h: styleH, isAuto: false };
+    }
+    if (typeof styleH === "string" && styleH.endsWith("%")) {
+        const pct = parseFloat(styleH);
+        if (!isNaN(pct))
+            return { h: (pct / 100) * parentH, isAuto: false };
+    }
+    return { h: 0, isAuto: true };
+}
+function resolveNode(node, parentFrame, slotBox, ctx, overflow) {
+    const margin = resolveSides(node.style.margin);
+    const pad = resolveSides(node.style.padding);
+    let boxW;
+    let boxH;
+    let boxX;
+    let boxY;
+    const hRes = resolveBoxHeight(node.style.h, parentFrame.h);
+    if (slotBox) {
+        boxW = slotBox.w;
+        boxH = slotBox.h !== 0 ? slotBox.h : hRes.h;
+        boxX = slotBox.x;
+        boxY = slotBox.y;
+    }
+    else {
+        boxW = resolveLen(node.style.w, parentFrame.w, parentFrame.w);
+        boxH = hRes.h;
+        const posRes = resolvePos(node.style.pos, parentFrame, boxW, boxH || parentFrame.h);
+        boxX = posRes.x;
+        boxY = posRes.y;
+    }
+    let margined = applyMargin({ x: boxX, y: boxY, w: boxW, h: boxH }, margin);
+    let contentFrame = applyPad(margined, pad);
+    // Fix container auto-height BEFORE resolving children — children need a real
+    // content frame for row distribution.
+    if (boxH === 0 && !node.measure) {
+        margined.h = parentFrame.h;
+        contentFrame.h = Math.max(0, parentFrame.h - pad.top - pad.bottom);
+    }
+    let children;
+    let textLayout;
+    if (node.split) {
+        children = resolveSplitChildren(node, node.split, contentFrame, ctx, overflow);
+    }
+    else if (node.children && node.children.length > 0) {
+        children = node.children.map((child) => resolveNode(child, contentFrame, null, ctx, overflow));
+    }
+    if (node.measure && contentFrame.w > 0) {
+        const measured = node.measure(contentFrame);
+        textLayout = {
+            lines: measured.lines,
+            fontSize: measured.ascent ? Math.round(measured.ascent / 0.8) : 14,
+            ascent: measured.ascent,
+            descent: measured.descent,
+        };
+        if (boxH === 0) {
+            const totalH = measured.h + pad.top + pad.bottom;
+            margined.h = Math.max(totalH, 1);
+            contentFrame.h = Math.max(measured.h, 1);
+        }
+        if (measured.h > contentFrame.h && contentFrame.h > 0) {
+            overflow.push({
+                path: "",
+                box: contentFrame,
+                fontSize: textLayout.fontSize,
+                text: measured.lines.join(" "),
+            });
+        }
+    }
+    const resolved = {
+        node,
+        box: { x: margined.x, y: margined.y, w: margined.w, h: margined.h },
+        contentFrame: { x: contentFrame.x, y: contentFrame.y, w: contentFrame.w, h: contentFrame.h },
+        textLayout,
+        children,
+    };
+    if (children) {
+        for (const c of children)
+            c.parent = resolved;
+    }
+    return resolved;
+}
+function resolveSplitChildren(node, split, contentFrame, ctx, overflow) {
+    const ch = node.children;
+    if (!ch || ch.length === 0)
+        return [];
+    const gap = "gap" in split && split.gap !== undefined ? resolveGap(split.gap, contentFrame.w) : 0;
+    const sp = "pad" in split && split.pad !== undefined ? resolveSides(split.pad) : resolveSides(undefined);
+    if ("rows" in split && (typeof split.rows === "number" || Array.isArray(split.rows))) {
+        const innerW = contentFrame.w - sp.left - sp.right;
+        const intrinsicHs = [];
+        for (let i = 0; i < ch.length; i++) {
+            intrinsicHs.push(estimateIntrinsicHeight(ch[i], innerW, ctx.measure));
+        }
+        const innerH = contentFrame.h - sp.top - sp.bottom;
+        const rowSpecs = resolveRowHeights(split.rows, innerH, gap, intrinsicHs);
+        const cells = splitRows(contentFrame, rowSpecs, gap, sp);
+        return ch.map((child, i) => {
+            const cell = cells[Math.min(i, cells.length - 1)];
+            return resolveNode(child, contentFrame, cell, ctx, overflow);
+        });
+    }
+    if ("cols" in split && (typeof split.cols === "number" || Array.isArray(split.cols))) {
+        const innerW = contentFrame.w - sp.left - sp.right;
+        const colSpecs = resolveColWidths(split.cols, innerW, gap);
+        const cells = splitCols(contentFrame, colSpecs, gap, sp);
+        return ch.map((child, i) => {
+            const cell = cells[Math.min(i, cells.length - 1)];
+            return resolveNode(child, contentFrame, cell, ctx, overflow);
+        });
+    }
+    if ("grid" in split) {
+        const cells = splitGrid(contentFrame, split.grid, gap, sp);
+        return ch.map((child, i) => {
+            const cell = cells[Math.min(i, cells.length - 1)];
+            return resolveNode(child, contentFrame, cell, ctx, overflow);
+        });
+    }
+    if ("zones" in split) {
+        const cells = splitZones(split.zones);
+        return ch.map((child, i) => {
+            const cell = cells[Math.min(i, cells.length - 1)];
+            return resolveNode(child, contentFrame, cell, ctx, overflow);
+        });
+    }
+    return [];
+}
+function estimateIntrinsicHeight(child, innerW, measure) {
+    if (!child.measure) {
+        if (child.children && child.children.length > 0) {
+            return 60; // default min row height for containers
+        }
+        return 0;
+    }
+    const avail = { x: 0, y: 0, w: innerW, h: 0 };
+    const m = child.measure(avail);
+    const pad = resolveSides(child.style.padding);
+    return m.h + pad.top + pad.bottom;
+}
+export function resolveLayout(root, world, hooks) {
+    const measure = hooks?.measure ?? defaultMeasure;
+    const overflow = [];
+    const resolved = resolveNode(root, world, null, { measure }, overflow);
+    const boxes = [];
+    flattenResolved(resolved, boxes);
+    resolveCollisions(boxes, world);
+    return { root: resolved, boxes, overflow };
+}

package/dist/split.d.ts

@@ -0,0 +1,39 @@
+import type { LBox, Len, Sides } from "./types.js";
+export declare function resolveSides(s: Sides | undefined): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export declare function resolveGap(gap: Len | undefined, parentSize: number): number;
+export interface ColSpec {
+    w: number;
+    kind: "fixed" | "pct" | "auto";
+    idx: number;
+}
+export interface RowSpec {
+    h: number;
+    kind: "fixed" | "pct" | "auto";
+    idx: number;
+}
+export declare function resolveColWidths(spec: number | Len[], parentW: number, gap: number): ColSpec[];
+export declare function splitCols(parentFrame: LBox, cols: ColSpec[], gap: number, pad: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}): LBox[];
+export declare function resolveRowHeights(spec: number | Len[], parentH: number, gap: number, childIntrinsicHs: number[]): RowSpec[];
+export declare function splitRows(parentFrame: LBox, rows: RowSpec[], gap: number, pad: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}): LBox[];
+export declare function splitGrid(parentFrame: LBox, grid: [cols: number, rows: number], gap: number, pad: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}): LBox[];
+export declare function splitZones(zones: Record<string, LBox>): LBox[];

package/dist/split.js

@@ -0,0 +1,151 @@
+export function resolveSides(s) {
+    if (s === undefined)
+        return { top: 0, right: 0, bottom: 0, left: 0 };
+    if (typeof s === "number")
+        return { top: s, right: s, bottom: s, left: s };
+    return { top: s.top ?? 0, right: s.right ?? 0, bottom: s.bottom ?? 0, left: s.left ?? 0 };
+}
+function resolveLen(v, parentSize, defaultVal) {
+    if (v === undefined)
+        return defaultVal;
+    if (v === "auto")
+        return defaultVal;
+    if (typeof v === "number")
+        return v;
+    const pct = parseFloat(v);
+    if (v.endsWith("%") && !isNaN(pct))
+        return (pct / 100) * parentSize;
+    return defaultVal;
+}
+export function resolveGap(gap, parentSize) {
+    return resolveLen(gap, parentSize, 0);
+}
+export function resolveColWidths(spec, parentW, gap) {
+    if (typeof spec === "number") {
+        const n = Math.max(1, spec);
+        const colW = (parentW - gap * (n - 1)) / n;
+        return Array.from({ length: n }, (_, i) => ({ w: colW, kind: "fixed", idx: i }));
+    }
+    let totalFixed = 0;
+    let totalPctPct = 0;
+    let autoCount = 0;
+    for (const s of spec) {
+        if (typeof s === "number") {
+            totalFixed += s;
+        }
+        else if (s === "auto") {
+            autoCount++;
+        }
+        else if (s.endsWith("%")) {
+            totalPctPct += parseFloat(s);
+        }
+    }
+    const totalPct = (totalPctPct / 100) * parentW;
+    const remaining = parentW - totalFixed - totalPct - gap * (spec.length - 1);
+    const autoW = autoCount > 0 ? Math.max(0, remaining / autoCount) : 0;
+    return spec.map((s, idx) => {
+        if (typeof s === "number")
+            return { w: s, kind: "fixed", idx };
+        if (s === "auto")
+            return { w: autoW, kind: "auto", idx };
+        const pct = parseFloat(s);
+        if (s.endsWith("%") && !isNaN(pct)) {
+            return { w: (pct / 100) * parentW, kind: "pct", idx };
+        }
+        return { w: 0, kind: "fixed", idx };
+    });
+}
+export function splitCols(parentFrame, cols, gap, pad) {
+    const innerX = parentFrame.x + pad.left;
+    const innerY = parentFrame.y + pad.top;
+    const innerW = parentFrame.w - pad.left - pad.right;
+    const innerH = parentFrame.h - pad.top - pad.bottom;
+    const boxes = [];
+    let cx = innerX;
+    for (const c of cols) {
+        boxes.push({ x: cx, y: innerY, w: c.w, h: innerH });
+        cx += c.w + gap;
+    }
+    return boxes;
+}
+export function resolveRowHeights(spec, parentH, gap, childIntrinsicHs) {
+    if (typeof spec === "number") {
+        const n = Math.max(1, spec);
+        const rowH = (parentH - gap * (n - 1)) / n;
+        return Array.from({ length: n }, (_, i) => ({ h: rowH, kind: "fixed", idx: i }));
+    }
+    const n = spec.length;
+    let usedFixed = 0;
+    let usedPct = 0;
+    const autoCount = spec.filter((s) => s === "auto").length;
+    for (let i = 0; i < n; i++) {
+        const s = spec[i];
+        if (typeof s === "number") {
+            usedFixed += s;
+        }
+        else if (typeof s === "string" && s.endsWith("%")) {
+            const pct = parseFloat(s);
+            if (!isNaN(pct))
+                usedPct += (pct / 100) * parentH;
+        }
+    }
+    const remaining = parentH - usedFixed - usedPct - gap * (n - 1);
+    const intrinsicTotal = childIntrinsicHs.reduce((a, b) => a + b, 0);
+    let autoH = 0;
+    if (autoCount > 0) {
+        if (intrinsicTotal <= remaining) {
+            autoH = intrinsicTotal / autoCount;
+        }
+        else {
+            autoH = remaining / autoCount;
+        }
+    }
+    return spec.map((s, idx) => {
+        if (typeof s === "number")
+            return { h: s, kind: "fixed", idx };
+        if (s === "auto")
+            return { h: autoH, kind: "auto", idx };
+        const pct = parseFloat(s);
+        if (s.endsWith("%") && !isNaN(pct)) {
+            return { h: (pct / 100) * parentH, kind: "pct", idx };
+        }
+        return { h: 0, kind: "fixed", idx };
+    });
+}
+export function splitRows(parentFrame, rows, gap, pad) {
+    const innerX = parentFrame.x + pad.left;
+    const innerY = parentFrame.y + pad.top;
+    const innerW = parentFrame.w - pad.left - pad.right;
+    const innerH = parentFrame.h - pad.top - pad.bottom;
+    const boxes = [];
+    let cy = innerY;
+    for (const r of rows) {
+        boxes.push({ x: innerX, y: cy, w: innerW, h: r.h });
+        cy += r.h + gap;
+    }
+    return boxes;
+}
+export function splitGrid(parentFrame, grid, gap, pad) {
+    const [nCols, nRows] = grid;
+    const innerX = parentFrame.x + pad.left;
+    const innerY = parentFrame.y + pad.top;
+    const innerW = parentFrame.w - pad.left - pad.right;
+    const innerH = parentFrame.h - pad.top - pad.bottom;
+    const cellW = (innerW - gap * (nCols - 1)) / nCols;
+    const cellH = (innerH - gap * (nRows - 1)) / nRows;
+    const cells = [];
+    for (let r = 0; r < nRows; r++) {
+        for (let c = 0; c < nCols; c++) {
+            cells.push({
+                x: innerX + c * (cellW + gap),
+                y: innerY + r * (cellH + gap),
+                w: cellW,
+                h: cellH,
+            });
+        }
+    }
+    return cells;
+}
+export function splitZones(zones) {
+    return Object.values(zones);
+}

package/dist/text-fit.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Self-contained text-fit helpers used by the default measure hook.
+ *
+ * These are intentionally measurement-agnostic: callers pass a `measure`
+ * closure (e.g. over a canvas `ctx.measureText`), so the engine never depends
+ * on a DOM or any specific rasterizer.
+ */
+/** Hard floor — nothing should render below this. */
+export declare const MIN_READABLE = 14;
+/**
+ * Shrink a font size so `text` fits within `maxWidth`, but never below the hard
+ * floor. Returns the largest size ≤ `size` that fits, or MIN_READABLE if even
+ * that overflows (the caller may then wrap). `measure(sizePx)` returns text
+ * width at that size.
+ */
+export declare function fitFontSize(size: number, maxWidth: number, measure: (sizePx: number) => number): number;
+/**
+ * Greedy word-wrap into lines that each fit `maxWidth`. `measure(text)` returns
+ * width at the current font. Long single words are kept whole.
+ */
+export declare function wrapText(text: string, maxWidth: number, measure: (text: string) => number): string[];

package/dist/text-fit.js

@@ -0,0 +1,48 @@
+/**
+ * Self-contained text-fit helpers used by the default measure hook.
+ *
+ * These are intentionally measurement-agnostic: callers pass a `measure`
+ * closure (e.g. over a canvas `ctx.measureText`), so the engine never depends
+ * on a DOM or any specific rasterizer.
+ */
+/** Hard floor — nothing should render below this. */
+export const MIN_READABLE = 14;
+/**
+ * Shrink a font size so `text` fits within `maxWidth`, but never below the hard
+ * floor. Returns the largest size ≤ `size` that fits, or MIN_READABLE if even
+ * that overflows (the caller may then wrap). `measure(sizePx)` returns text
+ * width at that size.
+ */
+export function fitFontSize(size, maxWidth, measure) {
+    if (maxWidth <= 0)
+        return size;
+    let s = size;
+    while (s > MIN_READABLE && measure(s) > maxWidth) {
+        s -= 1;
+    }
+    return Math.max(MIN_READABLE, s);
+}
+/**
+ * Greedy word-wrap into lines that each fit `maxWidth`. `measure(text)` returns
+ * width at the current font. Long single words are kept whole.
+ */
+export function wrapText(text, maxWidth, measure) {
+    if (maxWidth <= 0 || !text)
+        return [text];
+    const words = text.split(/\s+/);
+    const lines = [];
+    let cur = "";
+    for (const w of words) {
+        const trial = cur ? cur + " " + w : w;
+        if (measure(trial) <= maxWidth || !cur) {
+            cur = trial;
+        }
+        else {
+            lines.push(cur);
+            cur = w;
+        }
+    }
+    if (cur)
+        lines.push(cur);
+    return lines;
+}

package/dist/types.d.ts

@@ -0,0 +1,88 @@
+export interface LBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export type Sides = number | {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+export type Len = number | `${number}%` | "auto";
+export type Pos = {
+    x?: Len;
+    y?: Len;
+} | "center";
+export type Split = {
+    rows: number | Len[];
+    gap?: Len;
+    pad?: Sides;
+} | {
+    cols: number | Len[];
+    gap?: Len;
+    pad?: Sides;
+} | {
+    grid: [cols: number, rows: number];
+    gap?: Len;
+    pad?: Sides;
+} | {
+    zones: Record<string, LBox>;
+};
+export interface LStyle {
+    margin?: Sides;
+    padding?: Sides;
+    w?: Len;
+    h?: Len;
+    pos?: Pos;
+}
+export interface LNode {
+    id?: string;
+    style: LStyle;
+    measure?: (avail: LBox) => {
+        w: number;
+        h: number;
+        ascent: number;
+        descent: number;
+        lines: string[];
+    };
+    children?: LNode[];
+    split?: Split;
+}
+export interface TextLayout {
+    lines: string[];
+    fontSize: number;
+    ascent: number;
+    descent: number;
+}
+export interface ResolvedLNode {
+    node: LNode;
+    box: LBox;
+    contentFrame: LBox;
+    textLayout?: TextLayout;
+    children?: ResolvedLNode[];
+    parent?: ResolvedLNode;
+}
+export type Measure = (text: string, style: {
+    fontSize: number;
+    fontWeight?: number;
+    fontFamily?: string;
+}, maxW: number) => {
+    lines: string[];
+    w: number;
+    h: number;
+    ascent: number;
+    descent: number;
+};
+export interface OverflowSignal {
+    path: string;
+    box: LBox;
+    fontSize: number;
+    text: string;
+}
+export interface LayoutResult {
+    root: ResolvedLNode;
+    boxes: ResolvedLNode[];
+    overflow: OverflowSignal[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@canwork/boxwood",
+  "version": "1.0.0",
+  "description": "A Declarative Box-Split and Collision Engine for Vector Graphics. It provides a CSS-like layout grammar (padding, gap, cols, rows, auto-height), but outputs a clean JSON coordinate tree that any visual canvas (SVG, <canvas>, WebGL) can use to draw pixels, connectors, and particles.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "unpkg": "dist/boxwood.global.js",
+  "jsdelivr": "dist/boxwood.global.js",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:bundle": "esbuild index.ts --bundle --minify --format=iife --global-name=Boxwood --outfile=dist/boxwood.global.js",
+    "build:all": "npm run build && npm run build:bundle",
+    "prepublishOnly": "npm run build:all"
+  },
+  "keywords": [
+    "layout-engine",
+    "svg-layout",
+    "canvas-layout",
+    "vector-graphics",
+    "absolute-coordinates",
+    "box-model",
+    "declarative-layout",
+    "remotion"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/carnworkstudios/boxwood.git"
+  },
+  "bugs": {
+    "url": "https://github.com/carnworkstudios/boxwood/issues"
+  },
+  "homepage": "https://github.com/carnworkstudios/boxwood#readme",
+  "author": "Canwork Studios",
+  "license": "MIT",
+  "devDependencies": {
+    "esbuild": "^0.28.1",
+    "typescript": "^5.4.5"
+  }
+}