@nonbot/mcp 0.2.4 → 0.3.1

package/dist/core/layout.js

@@ -1,4 +1,5 @@
 import { IP_NODE_SIZE } from './ipShape.js';
+import { satelliteRowWidth, satellitePositions, satelliteBandHeight, INNER_LOOP_GAP, INNER_LOOP_Y_OFFSET, HOST_DEFAULT_HEIGHT } from './satellites.js';
 export const PX_PER_WEEK = 120;
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const ITEM_TOP_HANDLE_X = 8;
@@ -130,9 +131,6 @@ export function layoutTimeline(nodes, opts = {}) {
     const slot = (id, from) => ({ id, ...geo.get(id), ...(from ? { from } : {}) });
     const byX = (a, b) => geo.get(a.id).x - geo.get(b.id).x || a.id.localeCompare(b.id);
     let y = 0;
-    for (const o of items.filter(n => levelOf(n) === 'objective').sort(byX))
-        y = placeBand([slot(o.id)], y);
-    y = placeBand(items.filter(n => levelOf(n) === 'key-result').sort(byX).map(n => slot(n.id)), y);
     const ipNodes = nodes.filter(isIpNode);
     const ipFirstSource = new Map();
     const ipUnplaced = [];
@@ -143,14 +141,13 @@ export function layoutTimeline(nodes, opts = {}) {
         else
             ipUnplaced.push(n.id);
     }
-    const epics = items.filter(n => levelOf(n) === 'epic').sort(byX);
     const rest = items.filter(n => !['objective', 'key-result', 'epic'].includes(levelOf(n)));
-    for (const epic of [...epics.map(e => e.id), null]) {
+    const placeEpicBlock = (epic) => {
         const inBlock = rest.filter(n => epicOf(n) === epic);
         const blockIds = new Set([...(epic ? [epic] : []), ...inBlock.map(n => n.id)]);
         const ips = ipNodes.filter(n => blockIds.has(ipFirstSource.get(n.id) ?? ''));
         if (!epic && !inBlock.length && !ips.length)
-            continue;
+            return;
         if (y > 0)
             y += BLOCK_GAP - ROW_GAP;
         if (epic)
@@ -169,6 +166,59 @@ export function layoutTimeline(nodes, opts = {}) {
         pool.push(...leaves.filter(n => !featureIds.has(n.data?.parentItemId)).map(n => slot(n.id)));
         pool.push(...inBlock.filter(n => levelOf(n) === 'milestone').sort(byX).map(n => slot(n.id)));
         y = placeBand(pool, y);
+    };
+    const epics = items.filter(n => levelOf(n) === 'epic').sort(byX);
+    const objectives = items.filter(n => levelOf(n) === 'objective').sort(byX);
+    const krs = items.filter(n => levelOf(n) === 'key-result').sort(byX);
+    if (opts.group === 'objective') {
+        const epicIds = new Set(epics.map(e => e.id));
+        const linked = new Map();
+        const link = (kr, ep) => { if (epicIds.has(ep) && !(linked.get(kr) ?? []).includes(ep))
+            linked.set(kr, [...(linked.get(kr) ?? []), ep]); };
+        for (const e of opts.edges ?? [])
+            if (e.dependencyType === 'okr-link')
+                link(e.source, e.target);
+        for (const kr of krs)
+            for (const ep of (Array.isArray(kr.data?.linkedEpicIds) ? kr.data.linkedEpicIds : []))
+                link(kr.id, ep);
+        const rank = new Map((opts.objectiveOrder ?? []).map((id, i) => [id, i]));
+        const ordered = [...objectives].sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity) || byX(a, b));
+        const placedEpics = new Set();
+        const placeGroup = (krList) => {
+            if (krList.length)
+                y = placeBand(krList.map(n => slot(n.id)), y);
+            for (const kr of krList) {
+                const own = (linked.get(kr.id) ?? []).filter(id => !placedEpics.has(id)).map(id => byId.get(id)).sort(byX);
+                for (const ep of own) {
+                    placedEpics.add(ep.id);
+                    placeEpicBlock(ep.id);
+                }
+            }
+        };
+        for (const o of ordered) {
+            if (y > 0)
+                y += BLOCK_GAP - ROW_GAP;
+            y = placeBand([slot(o.id)], y);
+            placeGroup(krs.filter(k => k.data?.parentItemId === o.id));
+        }
+        const objectiveIds = new Set(objectives.map(o => o.id));
+        const looseKrs = krs.filter(k => !objectiveIds.has(k.data?.parentItemId));
+        if (looseKrs.length) {
+            if (y > 0)
+                y += BLOCK_GAP - ROW_GAP;
+            placeGroup(looseKrs);
+        }
+        for (const ep of epics)
+            if (!placedEpics.has(ep.id))
+                placeEpicBlock(ep.id);
+        placeEpicBlock(null);
+    }
+    else {
+        for (const o of objectives)
+            y = placeBand([slot(o.id)], y);
+        y = placeBand(krs.map(n => slot(n.id)), y);
+        for (const epic of [...epics.map(e => e.id), null])
+            placeEpicBlock(epic);
     }
     ipUnplaced.forEach((id, k) => positions.set(id, { x: k * (IP_NODE_SIZE.width + LANE_GAP_X), y: y + BLOCK_GAP }));
     return { positions, widthOverride };
@@ -191,3 +241,471 @@ export function applyLayout(nodes, res) {
         return out;
     });
 }
+export const MAP_WIDTH = { epic: 280, feature: 260, story: 240, enabler: 240, milestone: 120, objective: 300, 'key-result': 260 };
+const MAP_HERO_EXTRA = 260;
+const MAP_GAP = 24;
+const MAP_INDENT = 32;
+export const MAP_GRID_COLS = 3;
+export const MAP_GRID_MAX_COLS = 6;
+const MAP_GRID_ROWS = 10;
+const MAP_COLUMN_GAP = 96;
+const MAP_BAND_GAP = 240;
+export function layoutMap(nodes, opts = {}) {
+    return layoutMapDetailed(nodes, opts).positions;
+}
+export function layoutMapDetailed(nodes, opts = {}) {
+    const heights = opts.heights ?? {};
+    const sizes = opts.sizes ?? {};
+    const items = nodes.filter(isItem);
+    const byId = new Map(items.map(n => [n.id, n]));
+    const out = new Map();
+    const measured = (n) => { const z = sizes[n.id]; return z && z.width > 0 && z.height > 0 ? z : null; };
+    const w = (n) => {
+        const m = measured(n);
+        if (m)
+            return m.width;
+        const cs = n.data?.canvasSize;
+        return cs && Number.isFinite(cs.width) ? cs.width : MAP_WIDTH[levelOf(n)];
+    };
+    const h = (n) => {
+        const m = measured(n);
+        if (m)
+            return m.height;
+        if (heights[n.id])
+            return heights[n.id];
+        const cs = n.data?.canvasSize;
+        if (cs && Number.isFinite(cs.height))
+            return cs.height;
+        const hero = Array.isArray(n.data?.pastedImages) && n.data.pastedImages.length > 0;
+        return HEIGHT[levelOf(n)] + (hero ? MAP_HERO_EXTRA : 0);
+    };
+    const tx = (n) => n.position?.x ?? 0;
+    const byTime = (a, b) => tx(a) - tx(b) || a.id.localeCompare(b.id);
+    const kids = new Map();
+    for (const n of items) {
+        const p = n.data?.parentItemId;
+        if (p && byId.has(p))
+            kids.set(p, [...(kids.get(p) ?? []), n]);
+    }
+    const childrenOf = (id) => (kids.get(id) ?? []).slice().sort(byTime);
+    const isDone = (n) => n.data?.state === 'done';
+    const grid = (leaves, x, y) => {
+        const cols = Math.min(MAP_GRID_MAX_COLS, Math.max(MAP_GRID_COLS, Math.ceil(leaves.length / MAP_GRID_ROWS)));
+        const colW = [];
+        leaves.forEach((n, i) => { const c = i % cols; colW[c] = Math.max(colW[c] ?? 0, w(n)); });
+        const colX = [];
+        colW.forEach((cw, c) => { colX[c] = c === 0 ? x : colX[c - 1] + colW[c - 1] + MAP_GAP; });
+        let bottom = y;
+        for (let i = 0; i < leaves.length; i += cols) {
+            const row = leaves.slice(i, i + cols);
+            let rowH = 0;
+            row.forEach((n, c) => { out.set(n.id, { x: colX[c], y: bottom }); rowH = Math.max(rowH, h(n)); });
+            bottom += rowH + MAP_GAP;
+        }
+        const right = colW.length ? colX[colW.length - 1] + colW[colW.length - 1] : x;
+        return { bottom, right };
+    };
+    const placed = new Set();
+    const colCap = opts.columnHeight ?? Infinity;
+    const column = (epic, x, top, loose = []) => {
+        let y = top;
+        let right = x;
+        let colX = x;
+        let flowTop = top;
+        const maybeWrap = () => { if (y - top > colCap && y > flowTop) {
+            colX = right + MAP_COLUMN_GAP / 2;
+            y = flowTop;
+        } };
+        const take = (n, nx, ny) => { out.set(n.id, { x: nx, y: ny }); placed.add(n.id); right = Math.max(right, nx + w(n)); return ny + h(n) + MAP_GAP; };
+        const leavesGrid = (list, gx) => {
+            if (!list.length)
+                return;
+            for (const n of list)
+                placed.add(n.id);
+            const g = grid(list, gx, y);
+            y = g.bottom;
+            right = Math.max(right, g.right);
+        };
+        const descend = (id, gx, depth = 1) => {
+            const at = () => (depth === 1 ? colX + MAP_INDENT : gx);
+            const all = childrenOf(id).filter(n => !placed.has(n.id)).sort((a, b) => Number(isDone(a)) - Number(isDone(b)));
+            const containers = all.filter(n => (kids.get(n.id) ?? []).length > 0 || levelOf(n) === 'feature');
+            const leaves = all.filter(n => !containers.includes(n) && levelOf(n) !== 'milestone');
+            const ms = all.filter(n => !containers.includes(n) && levelOf(n) === 'milestone');
+            for (const c of containers) {
+                if (depth === 1)
+                    maybeWrap();
+                const cx = at();
+                y = take(c, cx, y);
+                descend(c.id, cx + MAP_INDENT, depth + 1);
+            }
+            if (leaves.length && depth === 1)
+                maybeWrap();
+            leavesGrid(leaves, at());
+            for (const m of ms)
+                y = take(m, at(), y);
+        };
+        if (epic) {
+            y = take(epic, x, y);
+            flowTop = y;
+            descend(epic.id, x + MAP_INDENT);
+        }
+        for (const n of loose)
+            if (!placed.has(n.id)) {
+                y = take(n, x, y);
+                descend(n.id, x + MAP_INDENT);
+            }
+        return { right, bottom: y };
+    };
+    const objectives = items.filter(n => levelOf(n) === 'objective');
+    const krs = items.filter(n => levelOf(n) === 'key-result').sort(byTime);
+    const epics = items.filter(n => levelOf(n) === 'epic' && !byId.has(n.data?.parentItemId)).sort(byTime);
+    const epicIds = new Set(epics.map(e => e.id));
+    const linked = new Map();
+    const link = (kr, ep) => { if (epicIds.has(ep) && !(linked.get(kr) ?? []).includes(ep))
+        linked.set(kr, [...(linked.get(kr) ?? []), ep]); };
+    for (const e of opts.edges ?? [])
+        if (e.dependencyType === 'okr-link')
+            link(e.source, e.target);
+    for (const kr of krs)
+        for (const ep of (Array.isArray(kr.data?.linkedEpicIds) ? kr.data.linkedEpicIds : []))
+            link(kr.id, ep);
+    const rank = new Map((opts.objectiveOrder ?? []).map((id, i) => [id, i]));
+    const ordered = objectives.slice().sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity) || byTime(a, b));
+    const headerH = opts.headerHeight ?? 0;
+    const allById = new Map(nodes.map(n => [n.id, n]));
+    const modW = (m) => sizes[m.id]?.width || Number(m.data?.width) || (isIpNode(m) ? IP_NODE_SIZE.width : 400);
+    const modH = (m) => sizes[m.id]?.height || Number(m.data?.height) || (isIpNode(m) ? IP_NODE_SIZE.height : 300);
+    const anyW = (n) => (n.type === 'rad-module' ? modW(n) : w(n));
+    const anyH = (n) => (n.type === 'rad-module' ? modH(n) : h(n));
+    const bands = [];
+    const capture = (kind, objective, header, fn) => {
+        const before = new Set(out.keys());
+        fn(header ? headerH : 0);
+        const ids = [...out.keys()].filter(k => !before.has(k));
+        if (!ids.length)
+            return;
+        let width = 0;
+        let height = header ? headerH : 0;
+        for (const id of ids) {
+            const p = out.get(id);
+            const n = allById.get(id);
+            width = Math.max(width, p.x + anyW(n));
+            height = Math.max(height, p.y + anyH(n));
+        }
+        const its = ids.map(id => allById.get(id)).filter(isItem);
+        bands.push({ kind, objectiveId: objective?.id ?? null, x: 0, y: 0, width, height, header, items: its.length, done: its.filter(isDone).length, epics: its.filter(n => levelOf(n) === 'epic').length, ids });
+    };
+    const ipNodes = nodes.filter(isIpNode);
+    const firstSource = (m) => (Array.isArray(m.data?.attachedItemIds) ? m.data.attachedItemIds : []).find((id) => byId.has(id));
+    const band = (top, lead, bandEpics) => {
+        const before = new Set(out.keys());
+        let x = 0;
+        if (lead.length) {
+            let y = top;
+            let right = 0;
+            for (const n of lead) {
+                out.set(n.id, { x: 0, y });
+                placed.add(n.id);
+                right = Math.max(right, w(n));
+                y += h(n) + MAP_GAP;
+            }
+            x = right + MAP_COLUMN_GAP;
+        }
+        for (const ep of bandEpics)
+            x = column(ep, x, top).right + MAP_COLUMN_GAP;
+        let y = top;
+        for (const m of ipNodes) {
+            const src = firstSource(m);
+            if (out.has(m.id) || !src || !out.has(src) || before.has(src))
+                continue;
+            out.set(m.id, { x, y });
+            y += modH(m) + MAP_GAP;
+        }
+    };
+    const placedEpics = new Set();
+    const epicsOf = (krList) => {
+        const list = [];
+        for (const kr of krList)
+            for (const id of linked.get(kr.id) ?? [])
+                if (!placedEpics.has(id)) {
+                    placedEpics.add(id);
+                    list.push(byId.get(id));
+                }
+        return list;
+    };
+    for (const o of ordered) {
+        const own = krs.filter(k => k.data?.parentItemId === o.id);
+        capture('objective', o, true, top => band(top, [o, ...own], epicsOf(own)));
+    }
+    const objectiveIds = new Set(objectives.map(o => o.id));
+    const looseKrs = krs.filter(k => !objectiveIds.has(k.data?.parentItemId));
+    const looseEpics = epicsOf(looseKrs);
+    const unlinked = epics.filter(e => !placedEpics.has(e.id));
+    for (const e of unlinked)
+        placedEpics.add(e.id);
+    capture('loose', null, true, top => band(top, looseKrs, [...looseEpics, ...unlinked]));
+    capture('rest', null, false, () => {
+        const rest = items.filter(n => !placed.has(n.id) && !byId.has(n.data?.parentItemId)).sort(byTime);
+        let y = rest.length ? column(null, 0, 0, rest).bottom : 0;
+        const stray = items.filter(n => !placed.has(n.id));
+        if (stray.length) {
+            for (const n of stray)
+                placed.add(n.id);
+            grid(stray, 0, y);
+        }
+    });
+    capture('modules', null, false, () => {
+        let mx = 0;
+        let my = 0;
+        let rowH = 0;
+        for (const m of nodes.filter(n => n.type === 'rad-module' && !out.has(n.id))) {
+            const mw = modW(m);
+            if (mx > 0 && mx + mw > 4 * 520) {
+                my += rowH + MAP_GAP;
+                mx = 0;
+                rowH = 0;
+            }
+            out.set(m.id, { x: mx, y: my });
+            mx += mw + MAP_GAP;
+            rowH = Math.max(rowH, modH(m));
+        }
+    });
+    const place = (b, dx, dy) => {
+        for (const id of b.ids) {
+            const p = out.get(id);
+            out.set(id, { x: p.x + dx, y: p.y + dy });
+        }
+        b.x = dx;
+        b.y = dy;
+    };
+    if (opts.pack === 'grid' && bands.length) {
+        const area = bands.reduce((sum, b) => sum + (b.width + MAP_BAND_GAP) * (b.height + MAP_BAND_GAP), 0);
+        const rowW = Math.max(...bands.map(b => b.width), Math.sqrt(area * (opts.aspect ?? 16 / 9)));
+        let x = 0;
+        let y = 0;
+        let rowH = 0;
+        for (const b of bands) {
+            if (x > 0 && x + b.width > rowW) {
+                y += rowH + MAP_BAND_GAP;
+                x = 0;
+                rowH = 0;
+            }
+            place(b, x, y);
+            x += b.width + MAP_BAND_GAP;
+            rowH = Math.max(rowH, b.height);
+        }
+    }
+    else {
+        let y = 0;
+        for (const b of bands) {
+            place(b, 0, y);
+            y += b.height + MAP_BAND_GAP;
+        }
+    }
+    return { positions: out, bands: bands.map(({ ids: _ids, ...b }) => b) };
+}
+export function applyMapLayout(nodes, positions) {
+    return nodes.map(n => {
+        const p = positions.get(n.id);
+        return p ? { ...n, freePosition: { x: Math.round(p.x), y: Math.round(p.y) } } : n;
+    });
+}
+export const FS_ROW = { objective: 0, 'key-result': 400, epic: 600, feature: 1040, milestone: 1320, story: 1480, enabler: 1480 };
+export const FS_EPIC_STAGGER = 20;
+export const FS_LEAF_PITCH = 240;
+export const FS_MILESTONE_LIFT_GAP = 20;
+export const FS_FEATURE_MIN_WIDTH = 600;
+export const FS_GROUP_GAP = 240;
+export function layoutFullStack(nodes, opts = {}) {
+    const sizes = opts.sizes ?? {};
+    const items = nodes.filter(isItem);
+    const byId = new Map(items.map(n => [n.id, n]));
+    const out = new Map();
+    const w = (n) => {
+        const z = sizes[n.id];
+        if (z && z.width > 0)
+            return z.width;
+        const cs = n.data?.canvasSize;
+        return cs && Number.isFinite(cs.width) && cs.width > 0 ? cs.width : MAP_WIDTH[levelOf(n)];
+    };
+    const tx = (n) => n.position?.x ?? 0;
+    const order = new Map(items.map((n, i) => [n.id, i]));
+    const byTime = (a, b) => tx(a) - tx(b) || order.get(a.id) - order.get(b.id);
+    const kids = new Map();
+    for (const n of items) {
+        const p = n.data?.parentItemId;
+        if (p && byId.has(p) && p !== n.id)
+            kids.set(p, [...(kids.get(p) ?? []), n]);
+    }
+    const put = (n, x, y) => out.set(n.id, { x, y });
+    const open = (list) => list.filter(n => !out.has(n.id)).sort(byTime);
+    const childrenOf = (id) => open(kids.get(id) ?? []);
+    const isMs = (n) => levelOf(n) === 'milestone';
+    const msH = (n) => {
+        const z = sizes[n.id];
+        if (z && z.height > 0)
+            return z.height;
+        const cs = n.data?.canvasSize;
+        return cs && Number.isFinite(cs.height) && cs.height > 0 ? cs.height : HEIGHT.milestone;
+    };
+    let x = 0;
+    let epicIndex = 0;
+    let epicBandRight = -Infinity;
+    let featureBandRight = -Infinity;
+    const clear = (cx, card, row, right) => (row > 0 && Number.isFinite(right) ? Math.max(cx, right + INNER_LOOP_GAP - card / 2 + row / 2) : cx);
+    const featureColumn = (f, fx0, stagger, under, epicBand) => {
+        const row = f ? satelliteRowWidth(f.data) : 0;
+        const fx = f ? clear(fx0, w(f), row, featureBandRight) : fx0;
+        if (f)
+            put(f, fx, FS_ROW.feature);
+        let lx = fx;
+        for (const l of under.filter(n => !isMs(n))) {
+            put(l, lx, FS_ROW.story);
+            lx += Math.max(FS_LEAF_PITCH, w(l));
+        }
+        const ms = under.filter(isMs);
+        const msW = ms.reduce((s, m) => s + w(m), 0);
+        let width = Math.max(lx - fx + msW, f ? Math.max(FS_FEATURE_MIN_WIDTH, w(f), row) : 0);
+        const raised = row > 0 && ms.length > 0;
+        const msY = raised ? FS_ROW.feature - Math.max(...ms.map(msH)) - FS_MILESTONE_LIFT_GAP : FS_ROW.milestone + stagger;
+        if (raised && epicBand && msY < epicBand.bottom && msY + Math.max(...ms.map(msH)) > epicBand.top) {
+            const left = fx + width - msW;
+            if (left < epicBand.right + INNER_LOOP_GAP && left + msW > epicBand.left - INNER_LOOP_GAP)
+                width = epicBand.right + INNER_LOOP_GAP + msW - fx;
+        }
+        let mx = fx + width - msW;
+        for (const m of ms) {
+            put(m, mx, msY);
+            mx += w(m);
+        }
+        if (f && row > 0)
+            featureBandRight = Math.max(featureBandRight, fx + w(f) / 2 + row / 2);
+        if (ms.length) {
+            if (raised)
+                epicBandRight = Math.max(epicBandRight, mx);
+            else
+                featureBandRight = Math.max(featureBandRight, mx);
+        }
+        return fx + width - fx0;
+    };
+    const epicColumn = (ep) => {
+        const stagger = FS_EPIC_STAGGER * (epicIndex++ % 2);
+        const row = satelliteRowWidth(ep.data);
+        const ex = clear(x, w(ep), row, epicBandRight);
+        const ey = FS_ROW.epic + stagger;
+        put(ep, ex, ey);
+        const band = row > 0
+            ? { left: ex + w(ep) / 2 - row / 2, right: ex + w(ep) / 2 + row / 2, top: ey + HOST_DEFAULT_HEIGHT.epic + INNER_LOOP_Y_OFFSET, bottom: ey + satelliteBandHeight(ep.data) }
+            : null;
+        if (band)
+            epicBandRight = Math.max(epicBandRight, band.right);
+        let cx = ex;
+        const ch = childrenOf(ep.id);
+        for (const f of ch.filter(n => levelOf(n) === 'feature'))
+            cx += featureColumn(f, cx, stagger, childrenOf(f.id), band);
+        const direct = ch.filter(n => levelOf(n) !== 'feature');
+        if (direct.length)
+            cx += featureColumn(null, cx, stagger, direct, band);
+        x = ex + Math.max(cx - ex, w(ep), row);
+        return ex;
+    };
+    const objectives = items.filter(n => levelOf(n) === 'objective');
+    const krs = items.filter(n => levelOf(n) === 'key-result').sort(byTime);
+    const epics = items.filter(n => levelOf(n) === 'epic').sort(byTime);
+    const epicIds = new Set(epics.map(e => e.id));
+    const linked = new Map();
+    const link = (kr, ep) => { if (epicIds.has(ep) && !(linked.get(kr) ?? []).includes(ep))
+        linked.set(kr, [...(linked.get(kr) ?? []), ep]); };
+    for (const e of opts.edges ?? [])
+        if (e.dependencyType === 'okr-link')
+            link(e.source, e.target);
+    for (const kr of krs)
+        for (const ep of (Array.isArray(kr.data?.linkedEpicIds) ? kr.data.linkedEpicIds : []))
+            link(kr.id, ep);
+    const rank = new Map((opts.objectiveOrder ?? []).map((id, i) => [id, i]));
+    const ordered = objectives.slice().sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity) || byTime(a, b));
+    let started = false;
+    const group = (fn) => {
+        const before = out.size;
+        const at = x;
+        if (started)
+            x += FS_GROUP_GAP;
+        fn();
+        if (out.size === before)
+            x = at;
+        else
+            started = true;
+    };
+    const krColumn = (kr) => {
+        const own = open((linked.get(kr.id) ?? []).map(id => byId.get(id)));
+        if (!own.length) {
+            put(kr, x, FS_ROW['key-result']);
+            x += w(kr) + MAP_GAP;
+            return;
+        }
+        let first = null;
+        for (const ep of own) {
+            const ex = epicColumn(ep);
+            first ??= ex;
+        }
+        put(kr, first, FS_ROW['key-result']);
+    };
+    for (const o of ordered)
+        group(() => {
+            const ox = x;
+            put(o, ox, FS_ROW.objective);
+            for (const kr of krs.filter(k => k.data?.parentItemId === o.id))
+                krColumn(kr);
+            x = Math.max(x, ox + w(o));
+        });
+    const objectiveIds = new Set(objectives.map(o => o.id));
+    group(() => { for (const kr of krs.filter(k => !objectiveIds.has(k.data?.parentItemId)))
+        krColumn(kr); });
+    group(() => { for (const ep of open(epics))
+        epicColumn(ep); });
+    group(() => {
+        for (const f of open(items.filter(n => levelOf(n) === 'feature')))
+            x += featureColumn(f, x, 0, childrenOf(f.id), null);
+        const loose = open(items.filter(n => !byId.has(n.data?.parentItemId) && ['story', 'enabler', 'milestone'].includes(levelOf(n))));
+        if (loose.length)
+            x += featureColumn(null, x, 0, loose, null);
+        for (const n of open(items)) {
+            put(n, x, FS_ROW[levelOf(n)]);
+            x += Math.max(FS_LEAF_PITCH, w(n));
+        }
+    });
+    return out;
+}
+export function applyFullStackTimeline(nodes, positions) {
+    return nodes.map(n => {
+        const p = positions.get(n.id);
+        return p ? { ...n, position: { ...(n.position ?? { x: 0 }), y: Math.round(p.y) } } : n;
+    });
+}
+export function timelineRowOverlaps(nodes) {
+    const cards = nodes.filter(isItem).map(n => {
+        const lv = levelOf(n);
+        const weeks = typeof n.data?.durationWeeks === 'number' ? n.data.durationWeeks : DEFAULT_DURATION[lv];
+        const width = Number(n.data?.manualWidthOverride) || (weeks > 0 ? weeks * PX_PER_WEEK : DEFAULT_WIDTH[lv]);
+        return { x: n.position?.x ?? 0, y: n.position?.y ?? 0, width };
+    });
+    let count = 0;
+    for (let i = 0; i < cards.length; i++)
+        for (let j = i + 1; j < cards.length; j++) {
+            const a = cards[i], b = cards[j];
+            if (Math.abs(a.y - b.y) < 100 && a.x < b.x + b.width && b.x < a.x + a.width)
+                count++;
+        }
+    return count;
+}
+export function mapBoxes(n) {
+    const at = n.freePosition ?? n.position ?? { x: 0, y: 0 };
+    if (n.type === 'rad-module')
+        return [{ x: at.x, y: at.y, width: Number(n.data?.width) || 400, height: Number(n.data?.height) || 300 }];
+    const cs = n.data?.canvasSize;
+    const width = cs && Number.isFinite(cs.width) && cs.width > 0 ? cs.width : MAP_WIDTH[levelOf(n)];
+    const height = cs && Number.isFinite(cs.height) && cs.height > 0 ? cs.height : HEIGHT[levelOf(n)] + (Array.isArray(n.data?.pastedImages) && n.data.pastedImages.length ? MAP_HERO_EXTRA : 0);
+    const card = { x: at.x, y: at.y, width, height };
+    return [card, ...satellitePositions(n.data, card).map(({ x, y, width: w, height: h }) => ({ x, y, width: w, height: h }))];
+}

package/dist/core/mapHeaders.d.ts

@@ -0,0 +1,13 @@
+import type { LayoutNode, MapBand } from './layout.js';
+export declare const HEADER_MARKER = "__layoutHeader";
+export declare const HEADER_TIMELINE_X = -6000;
+export declare function headerText(b: MapBand, title: string): {
+    title: string;
+    body: string;
+};
+export declare function withMapHeaders<T extends LayoutNode>(nodes: T[], bands: MapBand[], headerHeight: number, now?: number): {
+    nodes: T[];
+    added: number;
+    updated: number;
+    removed: number;
+};

package/dist/core/mapHeaders.js

@@ -0,0 +1,64 @@
+export const HEADER_MARKER = '__layoutHeader';
+export const HEADER_TIMELINE_X = -6000;
+const MAX_NOTE_WIDTH = 2400;
+const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const keyOf = (b) => b.objectiveId ?? b.kind;
+export function headerText(b, title) {
+    const pct = b.items ? Math.round((b.done / b.items) * 100) : 0;
+    const epics = `${b.epics} epic${b.epics === 1 ? '' : 's'}`;
+    const line = `${epics} · ${b.done} of ${b.items} cards done (${pct}%)`;
+    return { title, body: `<h2>${esc(title)}</h2><p>${esc(line)}</p>` };
+}
+export function withMapHeaders(nodes, bands, headerHeight, now = Date.now()) {
+    const titleOf = new Map(nodes.map(n => [n.id, String(n.data?.title ?? '')]));
+    const wanted = new Map(bands.filter(b => b.header).map(b => [keyOf(b), b]));
+    let added = 0;
+    let updated = 0;
+    let removed = 0;
+    const timelineY = (b) => {
+        const o = b.objectiveId ? nodes.find(n => n.id === b.objectiveId) : undefined;
+        return o?.position?.y ?? 0;
+    };
+    const build = (b, id, prev) => {
+        const t = headerText(b, b.objectiveId ? titleOf.get(b.objectiveId) || 'Objective' : 'Not linked to a goal yet');
+        const size = { width: Math.min(MAX_NOTE_WIDTH, Math.max(600, Math.round(b.width))), height: Math.max(80, headerHeight - 40) };
+        const prevModule = (prev?.data?.moduleData ?? {});
+        return {
+            ...(prev ?? {}),
+            id,
+            type: 'rad-module',
+            position: { x: HEADER_TIMELINE_X, y: timelineY(b) },
+            freePosition: { x: Math.round(b.x), y: Math.round(b.y) },
+            data: {
+                ...(prev?.data ?? {}),
+                subtype: 'document',
+                width: size.width,
+                height: size.height,
+                moduleData: { files: [], images: [], ...prevModule, title: t.title, body: t.body, __chromeCollapsed: true, __noteSize: size, [HEADER_MARKER]: keyOf(b) },
+            },
+        };
+    };
+    const out = [];
+    for (const n of nodes) {
+        const k = n.type === 'rad-module' && n.data?.subtype === 'document' ? n.data?.moduleData?.[HEADER_MARKER] : undefined;
+        if (typeof k !== 'string') {
+            out.push(n);
+            continue;
+        }
+        const b = wanted.get(k);
+        if (!b) {
+            removed++;
+            continue;
+        }
+        out.push(build(b, n.id, n));
+        updated++;
+        wanted.delete(k);
+    }
+    let i = 0;
+    for (const [k, b] of wanted) {
+        const slug = k.replace(/[^a-zA-Z0-9]/g, '').slice(-12) || String(i);
+        out.push(build(b, `radmod-document-${now}-hdr${slug}${i++}`));
+        added++;
+    }
+    return { nodes: out, added, updated, removed };
+}

package/dist/core/preview.d.ts

@@ -0,0 +1,18 @@
+import { type LayoutNode } from './layout.js';
+export interface PreviewOptions {
+    view?: 'map' | 'timeline';
+    sizes?: Record<string, {
+        width: number;
+        height: number;
+    }>;
+    width?: number;
+}
+export declare function renderPreviewSvg(nodes: LayoutNode[], opts?: PreviewOptions): {
+    svg: string;
+    cards: number;
+    satellites: number;
+    extent: {
+        width: number;
+        height: number;
+    };
+};