@nonbot/mcp 0.2.4 → 0.3.0

package/dist/core/layout.js

@@ -130,9 +130,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 +140,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 +165,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 +240,273 @@ 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;
+    });
+}

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,17 @@
+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;
+    extent: {
+        width: number;
+        height: number;
+    };
+};

package/dist/core/preview.js

@@ -0,0 +1,74 @@
+import { MAP_WIDTH, levelOf, isItem } from './layout.js';
+const HEIGHT = { epic: 120, feature: 100, story: 96, enabler: 96, milestone: 44, objective: 120, 'key-result': 100 };
+const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const strip = (s) => s.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+const fit = (s, px, size) => { const max = Math.max(3, Math.floor(px / (size * 0.56))); return s.length > max ? s.slice(0, max - 1) + '…' : s; };
+export function renderPreviewSvg(nodes, opts = {}) {
+    const view = opts.view ?? 'map';
+    const pos = (n) => (view === 'map' ? (n.freePosition ?? n.position) : n.position) ?? { x: 0, y: 0 };
+    const size = (n) => {
+        const m = opts.sizes?.[n.id];
+        if (m)
+            return m;
+        if (n.type === 'rad-module') {
+            const ns = n.data?.moduleData?.__noteSize;
+            if (n.data?.moduleData?.__chromeCollapsed && ns?.width)
+                return ns;
+            return { width: Number(n.data?.width) || 400, height: Number(n.data?.height) || 300 };
+        }
+        const cs = n.data?.canvasSize;
+        if (view === 'map' && cs?.width)
+            return cs;
+        const lv = levelOf(n);
+        return { width: MAP_WIDTH[lv], height: HEIGHT[lv] };
+    };
+    const drawn = nodes.filter(n => isItem(n) || n.type === 'rad-module');
+    if (!drawn.length)
+        return { svg: '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"/>', cards: 0, extent: { width: 0, height: 0 } };
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const n of drawn) {
+        const p = pos(n);
+        const s = size(n);
+        x0 = Math.min(x0, p.x);
+        y0 = Math.min(y0, p.y);
+        x1 = Math.max(x1, p.x + s.width);
+        y1 = Math.max(y1, p.y + s.height);
+    }
+    const pad = 80;
+    const W = x1 - x0 + 2 * pad;
+    const H = y1 - y0 + 2 * pad;
+    const outW = opts.width ?? 1600;
+    const parts = [];
+    for (const n of drawn) {
+        const p = pos(n);
+        const s = size(n);
+        const x = p.x - x0 + pad, y = p.y - y0 + pad;
+        if (n.type === 'rad-module') {
+            const header = n.data?.moduleData?.__layoutHeader;
+            const title = String(n.data?.moduleData?.title ?? n.data?.subtype ?? 'module').trim();
+            const body = strip(String(n.data?.moduleData?.body ?? '')).replace(title, '').trim();
+            if (header) {
+                parts.push(`<text x="${x}" y="${y + 64}" font-size="64" font-weight="700" fill="#E6E1F5">${esc(fit(title, s.width, 64))}</text>`);
+                if (body)
+                    parts.push(`<text x="${x}" y="${y + 130}" font-size="36" fill="#A79FC4">${esc(fit(body, s.width, 36))}</text>`);
+            }
+            else {
+                parts.push(`<rect x="${x}" y="${y}" width="${s.width}" height="${s.height}" rx="10" fill="#2A2740" stroke="#4A4566" stroke-width="2"/>`);
+                parts.push(`<text x="${x + 14}" y="${y + 32}" font-size="22" fill="#C9C2E6">${esc(fit(title, s.width - 28, 22))}</text>`);
+            }
+            continue;
+        }
+        const lv = levelOf(n);
+        const done = n.data?.state === 'done';
+        const big = lv === 'epic' || lv === 'objective';
+        const fill = done ? '#CFEBD9' : big ? '#2B2152' : '#1F1B33';
+        const ink = done ? '#24563A' : '#ECE8FA';
+        const stroke = big ? '#7367F0' : done ? '#9BCFAF' : '#3E3860';
+        const fs = big ? 26 : lv === 'feature' || lv === 'key-result' ? 21 : 18;
+        parts.push(`<rect x="${x}" y="${y}" width="${s.width}" height="${s.height}" rx="10" fill="${fill}" stroke="${stroke}" stroke-width="${big ? 4 : 2}"/>`);
+        parts.push(`<text x="${x + 14}" y="${y + 24}" font-size="13" fill="${done ? '#4E8A66' : '#8F87B5'}" letter-spacing="1">${esc(lv.toUpperCase())}${done ? ' · DONE' : n.data?.state ? ' · ' + esc(String(n.data.state).toUpperCase()) : ''}</text>`);
+        parts.push(`<text x="${x + 14}" y="${y + 28 + fs * 1.3}" font-size="${fs}" font-weight="${big ? 700 : 500}" fill="${ink}">${esc(fit(String(n.data?.title ?? '').trim(), s.width - 28, fs))}</text>`);
+    }
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${outW}" height="${Math.round((outW * H) / W)}" viewBox="0 0 ${Math.round(W)} ${Math.round(H)}" font-family="Public Sans, Helvetica, Arial, sans-serif"><rect width="100%" height="100%" fill="#120F1E"/>${parts.join('')}</svg>`;
+    return { svg, cards: drawn.length, extent: { width: Math.round(W), height: Math.round(H) } };
+}

package/dist/core/releases.d.ts

@@ -0,0 +1,127 @@
+export declare const RELEASE_SUBTYPE = "release";
+export declare const RELEASE_KEY: "releaseId";
+export declare const DONE_AT_KEY: "doneAt";
+export declare const RELEASE_SIZE: {
+    readonly width: 300;
+    readonly height: 184;
+};
+export interface ReleaseData {
+    name: string;
+    from: string;
+    to: string;
+    summary?: string;
+    highlights?: string[];
+    draft?: boolean;
+    approvedAt?: number;
+    open?: boolean;
+    proposed?: string[];
+}
+export type Item = {
+    id: string;
+    data?: Record<string, unknown>;
+};
+export type Edge = {
+    source: string;
+    target: string;
+    dependencyType?: string;
+    type?: string;
+};
+export type ReleaseModule = {
+    id: string;
+    subtype: string;
+    data: Record<string, unknown>;
+};
+export type ReleaseMap = ReadonlyMap<string, ReleaseModule>;
+export declare const releaseIdOf: (n: Item) => string | null;
+export declare function releasesById(modules: ReadonlyArray<ReleaseModule>): Map<string, ReleaseModule>;
+export declare const releaseIsOpen: (r: ReleaseModule) => boolean;
+export declare function isHiddenByRelease(n: Item, releases: ReleaseMap): boolean;
+export declare function isFiled(n: Item, releases: ReleaseMap): boolean;
+export declare function membersOf<T extends Item>(releaseId: string, nodes: ReadonlyArray<T>): T[];
+export declare function subtreeOf(rootIds: ReadonlyArray<string>, nodes: ReadonlyArray<Item>, edges?: ReadonlyArray<Edge>): Set<string>;
+export declare const isDone: (n: Item) => boolean;
+export declare function unfinishedIn(ids: Iterable<string>, nodes: ReadonlyArray<Item>): string[];
+export declare function doneAtOf(n: Item, now?: number): number;
+export interface FilePatch {
+    id: string;
+    patch: {
+        releaseId: string;
+        doneAt: number;
+    };
+}
+export declare function fileSet(ids: Iterable<string>, releaseId: string, nodes: ReadonlyArray<Item>, opts?: {
+    onlyDone?: boolean;
+    now?: number;
+}): FilePatch[];
+export declare function unfileSet(ids: Iterable<string>, nodes: ReadonlyArray<Item>): Array<{
+    id: string;
+    patch: {
+        releaseId: null;
+    };
+}>;
+export declare function memberCounts(releaseId: string, nodes: ReadonlyArray<Item>): Record<string, number>;
+export declare function previousRelease<R extends ReleaseModule>(from: string, releases: ReadonlyArray<R>, exceptId?: string): R | null;
+export declare function weekWindow(d?: Date): {
+    from: string;
+    to: string;
+};
+export declare function releaseOf(n: Item, releases: ReleaseMap): ReleaseModule | null;
+export declare function filedItemIds(nodes: ReadonlyArray<Item>, releases: ReleaseMap): Set<string>;
+export declare function releaseModulesFromGraphNodes(nodes: ReadonlyArray<unknown>): Map<string, ReleaseModule>;
+export interface ChainRelease {
+    id: string;
+    subtype: string;
+    data: Record<string, unknown>;
+    outConnectedNodeId?: string;
+    outConnectedNodeIds?: string[];
+}
+export interface ChainWrite {
+    id: string;
+    out: string | null;
+}
+export declare function outTargetsOf(inst: {
+    outConnectedNodeId?: string;
+    outConnectedNodeIds?: string[];
+}): string[];
+export declare function chainWrites(id: string, all: ReadonlyArray<ChainRelease>): ChainWrite[];
+export interface GraphNode {
+    id: string;
+    type?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    freePosition?: {
+        x: number;
+        y: number;
+    };
+    data?: Record<string, any>;
+}
+export declare function chainReleasesFromGraphNodes(nodes: ReadonlyArray<GraphNode>): ChainRelease[];
+export declare function applyChainWrites<T extends GraphNode>(nodes: ReadonlyArray<T>, writes: ReadonlyArray<ChainWrite>): T[];
+export declare function applyItemPatches<T extends GraphNode>(nodes: ReadonlyArray<T>, patches: ReadonlyArray<{
+    id: string;
+    patch: Record<string, unknown>;
+}>): T[];
+export declare function patchReleaseData<T extends GraphNode>(nodes: ReadonlyArray<T>, releaseId: string, patch: Record<string, unknown>): T[];
+export declare function newReleaseId(now?: number): string;
+export declare function placeRelease(nodes: ReadonlyArray<GraphNode>, from: string, prevId: string | null, xOfDate: (iso: string) => number): {
+    position: {
+        x: number;
+        y: number;
+    };
+    freePosition: {
+        x: number;
+        y: number;
+    };
+};
+export declare function releaseNode(id: string, md: ReleaseData, place: {
+    position: {
+        x: number;
+        y: number;
+    };
+    freePosition: {
+        x: number;
+        y: number;
+    };
+}): GraphNode;