@nonbot/mcp 0.2.4 → 0.3.1

package/dist/core/preview.js

@@ -0,0 +1,81 @@
+import { MAP_WIDTH, levelOf, isItem } from './layout.js';
+import { satellitePositions, SATELLITE_FIELDS } from './satellites.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, satellites: 0, extent: { width: 0, height: 0 } };
+    const bands = drawn.filter(isItem).flatMap(n => { const p = pos(n); const s = size(n); return satellitePositions(n.data, { x: p.x, y: p.y, width: s.width, height: s.height }); });
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    const grow = (x, y, w, h) => { x0 = Math.min(x0, x); y0 = Math.min(y0, y); x1 = Math.max(x1, x + w); y1 = Math.max(y1, y + h); };
+    for (const n of drawn) {
+        const p = pos(n);
+        const s = size(n);
+        grow(p.x, p.y, s.width, s.height);
+    }
+    for (const b of bands)
+        grow(b.x, b.y, b.width, b.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 b of bands) {
+        const x = b.x - x0 + pad, y = b.y - y0 + pad;
+        parts.push(`<rect x="${x}" y="${y}" width="${b.width}" height="${b.height}" rx="8" fill="#17142A" stroke="#4A4566" stroke-width="1.5" stroke-dasharray="6 4"/>`);
+        parts.push(`<text x="${x + 10}" y="${y + 20}" font-size="12" fill="#8F87B5">${esc(fit(SATELLITE_FIELDS[b.field].label, b.width - 20, 12))}</text>`);
+    }
+    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, satellites: bands.length, extent: { width: Math.round(W), height: Math.round(H) } };
+}

package/dist/core/releases.d.ts

@@ -0,0 +1,159 @@
+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;
+export interface LaneBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LaneRelease {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    data: Record<string, unknown>;
+}
+export interface LanePlace {
+    id: string;
+    x: number;
+    y: number;
+}
+export declare const LANE_GAP_X = 48;
+export declare const LANE_GAP_Y = 120;
+export declare function laneOrder<R extends {
+    id: string;
+    data: Record<string, unknown>;
+}>(releases: readonly R[]): R[];
+export declare function releaseLane(releases: readonly LaneRelease[], boxes: readonly LaneBox[]): LanePlace[];
+export declare function layoutReleaseLane(nodes: ReadonlyArray<GraphNode>, boxesOf: (n: GraphNode) => LaneBox[]): {
+    positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    y: number | null;
+};

package/dist/core/releases.js

@@ -0,0 +1,313 @@
+export const RELEASE_SUBTYPE = 'release';
+export const RELEASE_KEY = 'releaseId';
+export const DONE_AT_KEY = 'doneAt';
+export const RELEASE_SIZE = { width: 300, height: 184 };
+const dataOf = (n) => (n?.data ?? {});
+export const releaseIdOf = (n) => {
+    const v = dataOf(n)[RELEASE_KEY];
+    return typeof v === 'string' && v ? v : null;
+};
+export function releasesById(modules) {
+    const m = new Map();
+    for (const r of modules)
+        if (r.subtype === RELEASE_SUBTYPE)
+            m.set(r.id, r);
+    return m;
+}
+export const releaseIsOpen = (r) => r.data?.open === true;
+export function isHiddenByRelease(n, releases) {
+    const rid = releaseIdOf(n);
+    if (!rid)
+        return false;
+    const r = releases.get(rid);
+    return !!r && !releaseIsOpen(r);
+}
+export function isFiled(n, releases) {
+    const rid = releaseIdOf(n);
+    return !!rid && releases.has(rid);
+}
+export function membersOf(releaseId, nodes) {
+    return nodes.filter(n => releaseIdOf(n) === releaseId);
+}
+export function subtreeOf(rootIds, nodes, edges = []) {
+    const byParent = new Map();
+    const byId = new Map();
+    for (const n of nodes) {
+        byId.set(n.id, n);
+        const p = dataOf(n).parentItemId;
+        if (typeof p === 'string' && p)
+            (byParent.get(p) ?? byParent.set(p, []).get(p)).push(n.id);
+    }
+    const okr = new Map();
+    for (const e of edges)
+        if ((e.dependencyType ?? e.type) === 'okr-link')
+            (okr.get(e.source) ?? okr.set(e.source, []).get(e.source)).push(e.target);
+    const out = new Set();
+    const stack = [...rootIds];
+    while (stack.length) {
+        const id = stack.pop();
+        if (out.has(id) || !byId.has(id))
+            continue;
+        out.add(id);
+        for (const c of byParent.get(id) ?? [])
+            stack.push(c);
+        const linked = dataOf(byId.get(id)).linkedEpicIds;
+        if (Array.isArray(linked))
+            for (const x of linked)
+                if (typeof x === 'string')
+                    stack.push(x);
+        for (const t of okr.get(id) ?? [])
+            stack.push(t);
+    }
+    return out;
+}
+export const isDone = (n) => dataOf(n).state === 'done';
+export function unfinishedIn(ids, nodes) {
+    const byId = new Map(nodes.map(n => [n.id, n]));
+    const out = [];
+    for (const id of ids) {
+        const n = byId.get(id);
+        if (n && !isDone(n))
+            out.push(id);
+    }
+    return out;
+}
+export function doneAtOf(n, now = Date.now()) {
+    const d = dataOf(n);
+    for (const v of [d.doneAt, d.stateChangedAt, d.updatedAt])
+        if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+            return v;
+    return now;
+}
+export function fileSet(ids, releaseId, nodes, opts = {}) {
+    const byId = new Map(nodes.map(n => [n.id, n]));
+    const out = [];
+    for (const id of ids) {
+        const n = byId.get(id);
+        if (!n)
+            continue;
+        if (opts.onlyDone !== false && !isDone(n))
+            continue;
+        if (releaseIdOf(n) === releaseId)
+            continue;
+        out.push({ id, patch: { releaseId, doneAt: doneAtOf(n, opts.now) } });
+    }
+    return out;
+}
+export function unfileSet(ids, nodes) {
+    const byId = new Map(nodes.map(n => [n.id, n]));
+    const out = [];
+    for (const id of ids)
+        if (releaseIdOf(byId.get(id) ?? { id, data: {} }))
+            out.push({ id, patch: { releaseId: null } });
+    return out;
+}
+export function memberCounts(releaseId, nodes) {
+    const out = {};
+    for (const n of membersOf(releaseId, nodes)) {
+        const lvl = String(dataOf(n).hierarchyLevel ?? 'item');
+        out[lvl] = (out[lvl] ?? 0) + 1;
+    }
+    return out;
+}
+export function previousRelease(from, releases, exceptId) {
+    let best = null;
+    for (const r of releases) {
+        if (r.subtype !== RELEASE_SUBTYPE || r.id === exceptId)
+            continue;
+        const to = String(r.data?.to ?? '');
+        if (!to || to >= from)
+            continue;
+        if (!best || to > String(best.data.to ?? ''))
+            best = r;
+    }
+    return best;
+}
+const iso = (x) => `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, '0')}-${String(x.getDate()).padStart(2, '0')}`;
+export function weekWindow(d = new Date()) {
+    const day = (d.getDay() + 6) % 7;
+    const mon = new Date(d);
+    mon.setDate(d.getDate() - day);
+    const sun = new Date(mon);
+    sun.setDate(mon.getDate() + 6);
+    return { from: iso(mon), to: iso(sun) };
+}
+export function releaseOf(n, releases) {
+    const rid = releaseIdOf(n);
+    return (rid && releases.get(rid)) || null;
+}
+export function filedItemIds(nodes, releases) {
+    const out = new Set();
+    if (releases.size === 0)
+        return out;
+    for (const n of nodes)
+        if (isFiled(n, releases))
+            out.add(n.id);
+    return out;
+}
+export function releaseModulesFromGraphNodes(nodes) {
+    const out = new Map();
+    for (const raw of nodes) {
+        const n = raw;
+        if (!n || n.type !== 'rad-module' || typeof n.id !== 'string' || n.data?.subtype !== RELEASE_SUBTYPE)
+            continue;
+        const md = n.data.moduleData;
+        out.set(n.id, { id: n.id, subtype: RELEASE_SUBTYPE, data: md && typeof md === 'object' ? md : {} });
+    }
+    return out;
+}
+export function outTargetsOf(inst) {
+    const list = Array.isArray(inst.outConnectedNodeIds) ? inst.outConnectedNodeIds.filter(Boolean) : [];
+    const single = inst.outConnectedNodeId;
+    const ids = single && !list.includes(single) ? [single, ...list] : [...list];
+    return Array.from(new Set(ids));
+}
+const str = (v) => (typeof v === 'string' ? v : '');
+export function chainWrites(id, all) {
+    const releases = all.filter(r => r.subtype === RELEASE_SUBTYPE);
+    const self = releases.find(r => r.id === id);
+    if (!self)
+        return [];
+    const isRelease = (x) => !!x && releases.some(r => r.id === x);
+    const out = new Map();
+    for (const r of releases) {
+        const t = outTargetsOf(r)[0];
+        out.set(r.id, isRelease(t) ? t : null);
+    }
+    const original = new Map(out);
+    const mine = out.get(id) ?? null;
+    for (const r of releases)
+        if (r.id !== id && out.get(r.id) === id)
+            out.set(r.id, mine === r.id ? null : mine);
+    out.set(id, null);
+    const from = str(self.data.from);
+    const prev = from ? previousRelease(from, releases, id) : null;
+    if (prev) {
+        const next = out.get(prev.id) ?? null;
+        out.set(prev.id, id);
+        out.set(id, next && next !== id ? next : null);
+    }
+    else {
+        const to = str(self.data.to) || from;
+        let next = null;
+        for (const r of releases) {
+            if (r.id === id)
+                continue;
+            const f = str(r.data.from);
+            if (!f || !to || f <= to)
+                continue;
+            if (!next || f < str(next.data.from))
+                next = r;
+        }
+        const fed = next && [...out.entries()].some(([k, v]) => k !== id && v === next.id);
+        if (next && !fed)
+            out.set(id, next.id);
+    }
+    const writes = [];
+    for (const [k, v] of out)
+        if ((original.get(k) ?? null) !== v)
+            writes.push({ id: k, out: v });
+    return writes;
+}
+export function chainReleasesFromGraphNodes(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        if (n.type !== 'rad-module' || n.data?.subtype !== RELEASE_SUBTYPE)
+            continue;
+        const md = n.data.moduleData;
+        out.push({
+            id: n.id, subtype: RELEASE_SUBTYPE, data: md && typeof md === 'object' ? md : {},
+            ...(typeof n.data.outConnectedNodeId === 'string' ? { outConnectedNodeId: n.data.outConnectedNodeId } : {}),
+            ...(Array.isArray(n.data.outConnectedNodeIds) ? { outConnectedNodeIds: n.data.outConnectedNodeIds } : {}),
+        });
+    }
+    return out;
+}
+export function applyChainWrites(nodes, writes) {
+    if (!writes.length)
+        return [...nodes];
+    const w = new Map(writes.map(x => [x.id, x.out]));
+    return nodes.map(n => {
+        if (!w.has(n.id))
+            return n;
+        const { outConnectedNodeId: _o, outConnectedNodeIds: _l, ...rest } = n.data ?? {};
+        const out = w.get(n.id);
+        return { ...n, data: { ...rest, ...(out ? { outConnectedNodeId: out } : {}) } };
+    });
+}
+export function applyItemPatches(nodes, patches) {
+    if (!patches.length)
+        return [...nodes];
+    const p = new Map(patches.map(x => [x.id, x.patch]));
+    return nodes.map(n => (p.has(n.id) ? { ...n, data: { ...(n.data ?? {}), ...p.get(n.id) } } : n));
+}
+export function patchReleaseData(nodes, releaseId, patch) {
+    return nodes.map(n => (n.id === releaseId && n.type === 'rad-module' ? { ...n, data: { ...(n.data ?? {}), moduleData: { ...(n.data?.moduleData ?? {}), ...patch } } } : n));
+}
+export function newReleaseId(now = Date.now()) {
+    return `radmod-${RELEASE_SUBTYPE}-${now}-${Math.random().toString(36).slice(2, 8)}`;
+}
+const overlaps = (a, b) => Math.abs(a.x - b.x) < RELEASE_SIZE.width + 20 && Math.abs(a.y - b.y) < RELEASE_SIZE.height + 20;
+export function placeRelease(nodes, from, prevId, xOfDate) {
+    const cards = nodes.filter(n => n.type === 'portfolio-item');
+    const rels = nodes.filter(n => n.type === 'rad-module' && n.data?.subtype === RELEASE_SUBTYPE);
+    const GAP = 80;
+    const topY = cards.length ? Math.min(...cards.map(n => n.position?.y ?? 0)) : 0;
+    const pos = { x: xOfDate(from), y: topY - RELEASE_SIZE.height - GAP };
+    while (rels.some(r => r.position && overlaps(r.position, pos)))
+        pos.y -= RELEASE_SIZE.height + 24;
+    const freeOf = (n) => n.freePosition ?? n.position ?? { x: 0, y: 0 };
+    const prev = prevId ? rels.find(r => r.id === prevId) : undefined;
+    let free;
+    if (prev)
+        free = { x: freeOf(prev).x + RELEASE_SIZE.width + 60, y: freeOf(prev).y };
+    else {
+        const minX = cards.length ? Math.min(...cards.map(n => freeOf(n).x)) : 0;
+        const minY = cards.length ? Math.min(...cards.map(n => freeOf(n).y)) : 0;
+        free = { x: minX, y: minY - RELEASE_SIZE.height - 120 };
+    }
+    while (rels.some(r => overlaps(freeOf(r), free)))
+        free.x += RELEASE_SIZE.width + 60;
+    return { position: pos, freePosition: free };
+}
+export function releaseNode(id, md, place) {
+    return {
+        id, type: 'rad-module',
+        position: { ...place.position },
+        freePosition: { ...place.freePosition },
+        data: { subtype: RELEASE_SUBTYPE, moduleData: { ...md }, width: RELEASE_SIZE.width, height: RELEASE_SIZE.height },
+    };
+}
+export const LANE_GAP_X = 48;
+export const LANE_GAP_Y = 120;
+export function laneOrder(releases) {
+    return [...releases].sort((a, b) => str(a.data.from).localeCompare(str(b.data.from))
+        || str(a.data.to).localeCompare(str(b.data.to))
+        || a.id.localeCompare(b.id));
+}
+export function releaseLane(releases, boxes) {
+    if (!releases.length)
+        return [];
+    const live = boxes.filter(b => [b.x, b.y, b.width, b.height].every(Number.isFinite));
+    const left = live.length ? Math.min(...live.map(b => b.x)) : Math.min(...releases.map(r => r.x));
+    const top = live.length ? Math.max(...live.map(b => b.y + b.height)) + LANE_GAP_Y : Math.min(...releases.map(r => r.y));
+    const out = [];
+    let x = Math.round(left);
+    const y = Math.round(top);
+    for (const r of laneOrder(releases)) {
+        out.push({ id: r.id, x, y });
+        x += Math.round(Math.max(r.width, 1)) + LANE_GAP_X;
+    }
+    return out;
+}
+export function layoutReleaseLane(nodes, boxesOf) {
+    const isRel = (n) => n.type === 'rad-module' && n.data?.subtype === RELEASE_SUBTYPE;
+    const at = (n) => n.freePosition ?? n.position ?? { x: 0, y: 0 };
+    const releases = nodes.filter(isRel).map(n => ({
+        id: n.id, ...at(n), width: Number(n.data?.width) || RELEASE_SIZE.width,
+        data: n.data?.moduleData && typeof n.data.moduleData === 'object' ? n.data.moduleData : {},
+    }));
+    const boxes = nodes.filter(n => !isRel(n) && (n.type === 'portfolio-item' || n.type === 'rad-module')).flatMap(boxesOf);
+    const places = releaseLane(releases, boxes);
+    return { positions: new Map(places.map(p => [p.id, { x: p.x, y: p.y }])), y: places[0]?.y ?? null };
+}

package/dist/core/satellites.d.ts

@@ -0,0 +1,54 @@
+export declare const INNER_LOOP_GAP = 16;
+export declare const INNER_LOOP_Y_OFFSET = 40;
+export declare const INNER_LOOP_COLLAPSED_HEIGHT = 44;
+export declare const INNER_LOOP_FIELDS: readonly ["epicColor", "nodeDisplay", "artifact", "whyGraph", "description", "hypothesisStatement", "acceptanceCriteria", "bluf", "lbcProblem", "lbcBenefitHypothesis", "lbcLeadingIndicators", "lbcNfrs", "mvpDefinition", "outcomeMetrics", "owner", "tags", "confidenceVote", "approvalRating", "mockupSvg", "character", "location"];
+export type InnerLoopField = (typeof INNER_LOOP_FIELDS)[number];
+type FieldConfig = {
+    label: string;
+    width: number;
+    height: number;
+    levels?: readonly string[];
+    retired?: true;
+};
+export declare const SATELLITE_FIELDS: Record<InnerLoopField, FieldConfig>;
+export declare const HOST_DEFAULT_HEIGHT: Record<string, number>;
+export interface SatelliteHost {
+    hierarchyLevel?: string;
+    childCardType?: string;
+    innerLoopExpanded?: boolean;
+    innerLoopExtraFields?: string[];
+    innerLoopRemovedFields?: string[];
+    innerLoopSizes?: Record<string, {
+        width?: number;
+        height?: number;
+    }>;
+    subnodeCollapsed?: Record<string, boolean>;
+    [k: string]: unknown;
+}
+export declare const canHostInnerLoop: (d: SatelliteHost | undefined) => boolean;
+export declare function activeSatelliteFields(d: SatelliteHost | undefined): InnerLoopField[];
+export declare function satelliteItems(d: SatelliteHost | undefined): Array<{
+    field: InnerLoopField;
+    width: number;
+    height: number;
+}>;
+export declare const openSatellites: (d: SatelliteHost | undefined) => {
+    field: InnerLoopField;
+    width: number;
+    height: number;
+}[];
+export declare function satelliteRowWidth(d: SatelliteHost | undefined): number;
+export declare function satelliteBandHeight(d: SatelliteHost | undefined, hostHeight?: number): number;
+export declare function satellitePositions(d: SatelliteHost | undefined, host: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): Array<{
+    field: InnerLoopField;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+export {};