@flyingrobots/bijou 0.2.0 → 0.4.0

package/README.md

@@ -4,11 +4,14 @@ Themed terminal components for CLIs, loggers, and scripts — graceful degradati
 
 **Zero dependencies. Hexagonal architecture. Works everywhere.**
 
-## What's New in 0.2.0?
+## What's New in 0.4.0?
 
-- **`IOPort.onResize()`** — new port method for terminal resize events, enabling TUI apps to reflow layout when the terminal is resized
+- **`textarea()`** — multi-line text input form with cursor navigation, line numbers, placeholder, maxLength
+- **`filter()`** — fuzzy-filter select form with real-time search by label and keywords
+- **`dagLayout()`** — returns node position map alongside rendered output, for interactive DAG navigation
+- **`dag()` `selectedId`** — cursor-style node highlighting with highest priority over highlight path
 
-See the [CHANGELOG](https://github.com/flyingrobots/bijou/blob/main/CHANGELOG.md) for the full release history.
+See the [CHANGELOG](https://github.com/flyingrobots/bijou/blob/main/docs/CHANGELOG.md) for the full release history.
 
 ## Install
 

package/dist/core/components/dag.d.ts

@@ -0,0 +1,43 @@
+import type { BijouContext } from '../../ports/context.js';
+import type { TokenValue } from '../theme/tokens.js';
+export interface DagNode {
+    id: string;
+    label: string;
+    edges?: string[];
+    badge?: string;
+    token?: TokenValue;
+    /** @internal Used by dagSlice to mark ghost boundary nodes */
+    _ghost?: boolean;
+    _ghostLabel?: string;
+}
+export interface DagOptions {
+    nodeToken?: TokenValue;
+    edgeToken?: TokenValue;
+    highlightPath?: string[];
+    highlightToken?: TokenValue;
+    selectedId?: string;
+    selectedToken?: TokenValue;
+    nodeWidth?: number;
+    maxWidth?: number;
+    direction?: 'down' | 'right';
+    ctx?: BijouContext;
+}
+export interface DagNodePosition {
+    readonly row: number;
+    readonly col: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface DagLayout {
+    readonly output: string;
+    readonly nodes: ReadonlyMap<string, DagNodePosition>;
+    readonly width: number;
+    readonly height: number;
+}
+export declare function dagSlice(nodes: DagNode[], focus: string, opts?: {
+    direction?: 'ancestors' | 'descendants' | 'both';
+    depth?: number;
+}): DagNode[];
+export declare function dagLayout(nodes: DagNode[], options?: DagOptions): DagLayout;
+export declare function dag(nodes: DagNode[], options?: DagOptions): string;
+//# sourceMappingURL=dag.d.ts.map

package/dist/core/components/dag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag.d.ts","sourceRoot":"","sources":["../../../src/core/components/dag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAKrD,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B,GAAG,CAAC,EAAE,YAAY,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAiiBD,wBAAgB,QAAQ,CACtB,KAAK,EAAE,OAAO,EAAE,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;IACL,SAAS,CAAC,EAAE,WAAW,GAAG,aAAa,GAAG,MAAM,CAAC;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACA,OAAO,EAAE,CAuHX;AAID,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CAK/E;AAID,wBAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,OAAO,GAAE,UAAe,GAAG,MAAM,CAgBtE"}

package/dist/core/components/dag.js

@@ -0,0 +1,626 @@
+import { getDefaultContext } from '../../context.js';
+// ── Helpers ────────────────────────────────────────────────────────
+function resolveCtx(ctx) {
+    if (ctx)
+        return ctx;
+    return getDefaultContext();
+}
+function visibleLength(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+function truncateLabel(text, maxLen) {
+    if (maxLen <= 0)
+        return '';
+    if (visibleLength(text) <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + '\u2026';
+}
+// ── Layout: Layer Assignment ───────────────────────────────────────
+function assignLayers(nodes) {
+    const children = new Map();
+    const parents = new Map();
+    const inDegree = new Map();
+    const nodeIds = new Set(nodes.map(n => n.id));
+    for (const n of nodes) {
+        // Filter edges to only include targets that exist in the graph
+        children.set(n.id, (n.edges ?? []).filter(e => nodeIds.has(e)));
+        inDegree.set(n.id, 0);
+        if (!parents.has(n.id))
+            parents.set(n.id, []);
+    }
+    for (const n of nodes) {
+        for (const childId of children.get(n.id) ?? []) {
+            if (!parents.has(childId))
+                parents.set(childId, []);
+            parents.get(childId).push(n.id);
+            inDegree.set(childId, (inDegree.get(childId) ?? 0) + 1);
+        }
+    }
+    // Kahn's topological sort
+    const queue = [];
+    for (const [id, deg] of inDegree) {
+        if (deg === 0)
+            queue.push(id);
+    }
+    const topoOrder = [];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        topoOrder.push(id);
+        for (const childId of children.get(id) ?? []) {
+            const newDeg = (inDegree.get(childId) ?? 1) - 1;
+            inDegree.set(childId, newDeg);
+            if (newDeg === 0)
+                queue.push(childId);
+        }
+    }
+    if (topoOrder.length !== nodes.length) {
+        throw new Error('[bijou] dag(): cycle detected in graph');
+    }
+    // Longest-path layer assignment
+    const layerMap = new Map();
+    for (const id of topoOrder) {
+        const pars = parents.get(id) ?? [];
+        if (pars.length === 0) {
+            layerMap.set(id, 0);
+        }
+        else {
+            let maxParent = 0;
+            for (const p of pars) {
+                maxParent = Math.max(maxParent, layerMap.get(p) ?? 0);
+            }
+            layerMap.set(id, maxParent + 1);
+        }
+    }
+    return layerMap;
+}
+// ── Layout: Column Ordering ────────────────────────────────────────
+function buildLayerArrays(nodes, layerMap) {
+    let maxLayer = 0;
+    for (const v of layerMap.values()) {
+        if (v > maxLayer)
+            maxLayer = v;
+    }
+    const layers = Array.from({ length: maxLayer + 1 }, () => []);
+    for (const n of nodes) {
+        const l = layerMap.get(n.id);
+        if (l !== undefined)
+            layers[l].push(n.id);
+    }
+    return layers;
+}
+function orderColumns(layers, nodes) {
+    const childrenMap = new Map();
+    const parentsMap = new Map();
+    for (const n of nodes) {
+        childrenMap.set(n.id, n.edges ?? []);
+        if (!parentsMap.has(n.id))
+            parentsMap.set(n.id, []);
+    }
+    for (const n of nodes) {
+        for (const c of n.edges ?? []) {
+            if (!parentsMap.has(c))
+                parentsMap.set(c, []);
+            parentsMap.get(c).push(n.id);
+        }
+    }
+    // Top-down pass
+    for (let l = 1; l < layers.length; l++) {
+        const prevLayer = layers[l - 1];
+        const curLayer = layers[l];
+        const prevIndex = new Map();
+        for (let i = 0; i < prevLayer.length; i++) {
+            prevIndex.set(prevLayer[i], i);
+        }
+        const bary = new Map();
+        for (const id of curLayer) {
+            const pars = (parentsMap.get(id) ?? []).filter(p => prevIndex.has(p));
+            if (pars.length === 0) {
+                bary.set(id, Infinity);
+            }
+            else {
+                const avg = pars.reduce((s, p) => s + (prevIndex.get(p) ?? 0), 0) / pars.length;
+                bary.set(id, avg);
+            }
+        }
+        curLayer.sort((a, b) => (bary.get(a) ?? Infinity) - (bary.get(b) ?? Infinity));
+    }
+    // Bottom-up pass
+    for (let l = layers.length - 2; l >= 0; l--) {
+        const nextLayer = layers[l + 1];
+        const curLayer = layers[l];
+        const nextIndex = new Map();
+        for (let i = 0; i < nextLayer.length; i++) {
+            nextIndex.set(nextLayer[i], i);
+        }
+        const bary = new Map();
+        for (const id of curLayer) {
+            const chlds = (childrenMap.get(id) ?? []).filter(c => nextIndex.has(c));
+            if (chlds.length === 0) {
+                bary.set(id, Infinity);
+            }
+            else {
+                const avg = chlds.reduce((s, c) => s + (nextIndex.get(c) ?? 0), 0) / chlds.length;
+                bary.set(id, avg);
+            }
+        }
+        curLayer.sort((a, b) => (bary.get(a) ?? Infinity) - (bary.get(b) ?? Infinity));
+    }
+}
+const JUNCTION = {
+    'D': '\u2502', 'U': '\u2502', 'DU': '\u2502',
+    'L': '\u2500', 'R': '\u2500', 'LR': '\u2500',
+    'DR': '\u250c', 'DL': '\u2510', 'RU': '\u2514', 'LU': '\u2518',
+    'DRU': '\u251c', 'DLU': '\u2524', 'DLR': '\u252c', 'LRU': '\u2534',
+    'DLRU': '\u253c',
+};
+function junctionChar(dirs) {
+    const key = [...dirs].sort().join('');
+    return JUNCTION[key] ?? '\u253c';
+}
+function createGrid(rows, cols) {
+    const dirs = [];
+    for (let r = 0; r < rows; r++) {
+        const row = [];
+        for (let c = 0; c < cols; c++) {
+            row.push(new Set());
+        }
+        dirs.push(row);
+    }
+    return { dirs, arrows: new Set(), rows, cols };
+}
+function markDir(g, r, c, ...ds) {
+    if (r >= 0 && r < g.rows && c >= 0 && c < g.cols) {
+        const cell = g.dirs[r][c];
+        for (const d of ds)
+            cell.add(d);
+    }
+}
+function markEdge(g, fromCol, fromLayer, toCol, toLayer, RS, colCenter) {
+    const srcC = colCenter(fromCol);
+    const dstC = colCenter(toCol);
+    const sRow = fromLayer * RS + 3;
+    const dRow = toLayer * RS - 1; // one row above dest box
+    const mid = sRow + 1;
+    if (srcC === dstC) {
+        for (let r = sRow; r < dRow; r++)
+            markDir(g, r, srcC, 'D', 'U');
+    }
+    else {
+        markDir(g, sRow, srcC, 'D', 'U');
+        markDir(g, mid, srcC, srcC < dstC ? 'R' : 'L', 'U');
+        const minC = Math.min(srcC, dstC);
+        const maxC = Math.max(srcC, dstC);
+        for (let c = minC + 1; c < maxC; c++)
+            markDir(g, mid, c, 'L', 'R');
+        markDir(g, mid, dstC, srcC < dstC ? 'L' : 'R', 'D');
+        for (let r = mid + 1; r < dRow; r++)
+            markDir(g, r, dstC, 'D', 'U');
+    }
+    g.arrows.add(dRow * 10000 + dstC);
+}
+// ── Node Box Rendering ─────────────────────────────────────────────
+function renderNodeBox(label, badgeText, width, ghost) {
+    const h = ghost ? '\u254c' : '\u2500';
+    const v = ghost ? '\u254e' : '\u2502';
+    const innerW = width - 2;
+    const contentW = innerW - 2;
+    let content;
+    if (badgeText) {
+        const maxLabelW = contentW - visibleLength(badgeText) - 1;
+        const tLabel = truncateLabel(label, maxLabelW);
+        const gap = Math.max(1, contentW - visibleLength(tLabel) - visibleLength(badgeText));
+        content = tLabel + ' '.repeat(gap) + badgeText;
+    }
+    else {
+        content = truncateLabel(label, contentW);
+    }
+    const padRight = Math.max(0, contentW - visibleLength(content));
+    const top = '\u256d' + h.repeat(innerW) + '\u256e';
+    const mid = v + ' ' + content + ' '.repeat(padRight) + ' ' + v;
+    const bot = '\u2570' + h.repeat(innerW) + '\u256f';
+    return [top, mid, bot];
+}
+// ── Interactive Renderer ───────────────────────────────────────────
+function renderInteractiveLayout(nodes, options, ctx) {
+    if (nodes.length === 0)
+        return { output: '', nodes: new Map(), width: 0, height: 0 };
+    const nodeMap = new Map();
+    for (const n of nodes)
+        nodeMap.set(n.id, n);
+    const layerMap = assignLayers(nodes);
+    const layers = buildLayerArrays(nodes, layerMap);
+    orderColumns(layers, nodes);
+    const colIndex = new Map();
+    for (const layer of layers) {
+        for (let i = 0; i < layer.length; i++) {
+            colIndex.set(layer[i], i);
+        }
+    }
+    let maxNodesPerLayer = 1;
+    for (const layer of layers) {
+        if (layer.length > maxNodesPerLayer)
+            maxNodesPerLayer = layer.length;
+    }
+    const maxWidth = options.maxWidth ?? ctx.runtime.columns;
+    let nodeWidth = options.nodeWidth ?? Math.max(...nodes.map(n => visibleLength(n.label) + (n.badge ? visibleLength(n.badge) + 2 : 0) + 4), 16);
+    let gap = 4;
+    let colStride = nodeWidth + gap;
+    let totalWidth = maxNodesPerLayer * colStride;
+    if (totalWidth > maxWidth && !options.nodeWidth) {
+        gap = 2;
+        colStride = nodeWidth + gap;
+        totalWidth = maxNodesPerLayer * colStride;
+    }
+    if (totalWidth > maxWidth && !options.nodeWidth) {
+        nodeWidth = Math.max(16, Math.floor((maxWidth - gap) / maxNodesPerLayer) - gap);
+        colStride = nodeWidth + gap;
+        totalWidth = maxNodesPerLayer * colStride;
+    }
+    const RS = 6;
+    const gridRows = layers.length * RS;
+    const gridCols = totalWidth;
+    const colCenter = (c) => c * colStride + Math.floor(nodeWidth / 2);
+    const g = createGrid(gridRows, gridCols);
+    // Mark edges
+    for (const n of nodes) {
+        const fLayer = layerMap.get(n.id);
+        const fCol = colIndex.get(n.id);
+        if (fLayer === undefined || fCol === undefined)
+            continue;
+        for (const childId of n.edges ?? []) {
+            const tLayer = layerMap.get(childId);
+            const tCol = colIndex.get(childId);
+            if (tLayer === undefined || tCol === undefined)
+                continue;
+            markEdge(g, fCol, fLayer, tCol, tLayer, RS, colCenter);
+        }
+    }
+    // Build output grids
+    const charGrid = [];
+    const tokenGrid = [];
+    for (let r = 0; r < gridRows; r++) {
+        const charRow = [];
+        const tokenRow = [];
+        for (let c = 0; c < gridCols; c++) {
+            charRow.push(' ');
+            tokenRow.push(null);
+        }
+        charGrid.push(charRow);
+        tokenGrid.push(tokenRow);
+    }
+    // Write edge characters
+    const edgeToken = options.edgeToken ?? ctx.theme.theme.border.muted;
+    for (let r = 0; r < gridRows; r++) {
+        for (let c = 0; c < gridCols; c++) {
+            const cell = g.dirs[r][c];
+            if (cell.size > 0) {
+                charGrid[r][c] = junctionChar(cell);
+                tokenGrid[r][c] = edgeToken;
+            }
+        }
+    }
+    // Write arrowheads
+    for (const encoded of g.arrows) {
+        const r = Math.floor(encoded / 10000);
+        const c = encoded % 10000;
+        if (r >= 0 && r < gridRows && c >= 0 && c < gridCols) {
+            charGrid[r][c] = '\u25bc';
+            tokenGrid[r][c] = edgeToken;
+        }
+    }
+    // Highlight edges
+    const highlightSet = new Set(options.highlightPath ?? []);
+    if (options.highlightPath && options.highlightToken) {
+        const hlToken = options.highlightToken;
+        const path = options.highlightPath;
+        for (let i = 0; i < path.length - 1; i++) {
+            const fromId = path[i];
+            const toId = path[i + 1];
+            const fLayer = layerMap.get(fromId);
+            const tLayer = layerMap.get(toId);
+            const fCol = colIndex.get(fromId);
+            const tCol = colIndex.get(toId);
+            if (fLayer === undefined || tLayer === undefined || fCol === undefined || tCol === undefined)
+                continue;
+            const srcC = colCenter(fCol);
+            const dstC = colCenter(tCol);
+            const sRow = fLayer * RS + 3;
+            const dRow = tLayer * RS - 1;
+            const midRow = sRow + 1;
+            if (srcC === dstC) {
+                for (let r = sRow; r <= dRow && r < gridRows; r++) {
+                    if (srcC < gridCols)
+                        tokenGrid[r][srcC] = hlToken;
+                }
+            }
+            else {
+                if (sRow < gridRows && srcC < gridCols)
+                    tokenGrid[sRow][srcC] = hlToken;
+                const minC = Math.min(srcC, dstC);
+                const maxC2 = Math.max(srcC, dstC);
+                if (midRow < gridRows) {
+                    for (let c = minC; c <= maxC2 && c < gridCols; c++) {
+                        tokenGrid[midRow][c] = hlToken;
+                    }
+                }
+                for (let r = midRow; r <= dRow && r < gridRows; r++) {
+                    if (dstC < gridCols)
+                        tokenGrid[r][dstC] = hlToken;
+                }
+            }
+        }
+    }
+    // Write node boxes
+    const positions = new Map();
+    for (const n of nodes) {
+        const layer = layerMap.get(n.id);
+        const col = colIndex.get(n.id);
+        if (layer === undefined || col === undefined)
+            continue;
+        const startCol = col * colStride;
+        const startRow = layer * RS;
+        positions.set(n.id, { row: startRow, col: startCol, width: nodeWidth, height: 3 });
+        const boxLines = renderNodeBox(n.label, n.badge, nodeWidth, n._ghost === true);
+        let nToken;
+        if (options.selectedId === n.id) {
+            nToken = options.selectedToken ?? ctx.theme.theme.ui.cursor;
+        }
+        else if (highlightSet.has(n.id) && options.highlightToken) {
+            nToken = options.highlightToken;
+        }
+        else if (n.token) {
+            nToken = n.token;
+        }
+        else {
+            nToken = options.nodeToken ?? ctx.theme.theme.border.primary;
+        }
+        for (let lineIdx = 0; lineIdx < boxLines.length; lineIdx++) {
+            const row = startRow + lineIdx;
+            if (row >= gridRows)
+                continue;
+            const line = boxLines[lineIdx];
+            const chars = [...line];
+            for (let ci = 0; ci < chars.length; ci++) {
+                const gc = startCol + ci;
+                if (gc < gridCols) {
+                    charGrid[row][gc] = chars[ci];
+                    tokenGrid[row][gc] = nToken;
+                }
+            }
+        }
+    }
+    // Serialize
+    const lines = [];
+    for (let r = 0; r < gridRows; r++) {
+        let line = '';
+        let prevToken = null;
+        let run = '';
+        for (let c = 0; c < gridCols; c++) {
+            const ch = charGrid[r][c];
+            const tk = tokenGrid[r][c];
+            if (tk === prevToken || (tk === null && prevToken === null)) {
+                run += ch;
+            }
+            else {
+                if (run) {
+                    line += prevToken ? ctx.style.styled(prevToken, run) : run;
+                }
+                run = ch;
+                prevToken = tk;
+            }
+        }
+        if (run) {
+            line += prevToken ? ctx.style.styled(prevToken, run) : run;
+        }
+        lines.push(line.replace(/\s+$/, ''));
+    }
+    while (lines.length > 0 && lines[lines.length - 1].trim() === '') {
+        lines.pop();
+    }
+    return { output: lines.join('\n'), nodes: positions, width: gridCols, height: gridRows };
+}
+// ── Pipe Renderer ──────────────────────────────────────────────────
+function renderPipe(nodes) {
+    if (nodes.length === 0)
+        return '';
+    const lines = [];
+    for (const n of nodes) {
+        const edges = n.edges ?? [];
+        const badgePart = n.badge ? ` (${n.badge})` : '';
+        if (edges.length > 0) {
+            const targets = edges
+                .map(id => {
+                const target = nodes.find(t => t.id === id);
+                return target ? target.label : id;
+            })
+                .join(', ');
+            lines.push(`${n.label}${badgePart} -> ${targets}`);
+        }
+        else {
+            lines.push(`${n.label}${badgePart}`);
+        }
+    }
+    return lines.join('\n');
+}
+// ── Accessible Renderer ────────────────────────────────────────────
+function renderAccessible(nodes, layerMap) {
+    if (nodes.length === 0)
+        return 'Graph: 0 nodes, 0 edges';
+    const totalEdges = nodes.reduce((s, n) => s + (n.edges?.length ?? 0), 0);
+    const lines = [`Graph: ${nodes.length} nodes, ${totalEdges} edges`, ''];
+    const layers = buildLayerArrays(nodes, layerMap);
+    const nodeMap = new Map();
+    for (const n of nodes)
+        nodeMap.set(n.id, n);
+    for (let l = 0; l < layers.length; l++) {
+        lines.push(`Layer ${l + 1}:`);
+        for (const id of layers[l]) {
+            const n = nodeMap.get(id);
+            if (!n)
+                continue;
+            const badgePart = n.badge ? ` (${n.badge})` : '';
+            const edges = (n.edges ?? []).filter(e => nodeMap.has(e));
+            if (edges.length > 0) {
+                const targets = edges.map(e => nodeMap.get(e)?.label ?? e).join(', ');
+                lines.push(`  ${n.label}${badgePart} -> ${targets}`);
+            }
+            else {
+                lines.push(`  ${n.label}${badgePart} (end)`);
+            }
+        }
+        lines.push('');
+    }
+    while (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines.join('\n');
+}
+// ── dagSlice ───────────────────────────────────────────────────────
+export function dagSlice(nodes, focus, opts) {
+    const direction = opts?.direction ?? 'both';
+    const maxDepth = opts?.depth ?? Infinity;
+    const nodeMap = new Map();
+    for (const n of nodes)
+        nodeMap.set(n.id, n);
+    if (!nodeMap.has(focus))
+        return [];
+    const included = new Set();
+    const ghostIds = new Set();
+    // Build parent map
+    const parentsMap = new Map();
+    for (const n of nodes) {
+        if (!parentsMap.has(n.id))
+            parentsMap.set(n.id, []);
+        for (const c of n.edges ?? []) {
+            if (!parentsMap.has(c))
+                parentsMap.set(c, []);
+            parentsMap.get(c).push(n.id);
+        }
+    }
+    // BFS ancestors
+    if (direction === 'ancestors' || direction === 'both') {
+        const queue = [[focus, 0]];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const entry = queue.shift();
+            const id = entry[0];
+            const depth = entry[1];
+            if (visited.has(id))
+                continue;
+            visited.add(id);
+            included.add(id);
+            if (depth < maxDepth) {
+                for (const p of parentsMap.get(id) ?? []) {
+                    if (!visited.has(p))
+                        queue.push([p, depth + 1]);
+                }
+            }
+            else {
+                const boundaryParents = (parentsMap.get(id) ?? []).filter(p => !visited.has(p));
+                if (boundaryParents.length > 0) {
+                    const ghostId = `__ghost_ancestors_${id}`;
+                    ghostIds.add(ghostId);
+                    included.add(ghostId);
+                }
+            }
+        }
+    }
+    // BFS descendants
+    if (direction === 'descendants' || direction === 'both') {
+        const queue = [[focus, 0]];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const entry = queue.shift();
+            const id = entry[0];
+            const depth = entry[1];
+            if (visited.has(id))
+                continue;
+            visited.add(id);
+            included.add(id);
+            const ch = nodeMap.get(id)?.edges ?? [];
+            if (depth < maxDepth) {
+                for (const c of ch) {
+                    if (!visited.has(c) && nodeMap.has(c))
+                        queue.push([c, depth + 1]);
+                }
+            }
+            else {
+                const boundaryChildren = ch.filter(c => !visited.has(c) && nodeMap.has(c));
+                if (boundaryChildren.length > 0) {
+                    const ghostId = `__ghost_descendants_${id}`;
+                    ghostIds.add(ghostId);
+                    included.add(ghostId);
+                }
+            }
+        }
+    }
+    // Build result
+    const result = [];
+    for (const gid of ghostIds) {
+        if (gid.startsWith('__ghost_ancestors_')) {
+            const boundaryId = gid.replace('__ghost_ancestors_', '');
+            const allParents = (parentsMap.get(boundaryId) ?? []).filter(p => !included.has(p));
+            const count = allParents.length;
+            result.push({
+                id: gid,
+                label: `... ${count} ancestor${count !== 1 ? 's' : ''}`,
+                edges: [boundaryId],
+                _ghost: true,
+                _ghostLabel: `... ${count} ancestor${count !== 1 ? 's' : ''}`,
+            });
+        }
+    }
+    for (const n of nodes) {
+        if (!included.has(n.id))
+            continue;
+        const filteredEdges = (n.edges ?? []).filter(e => included.has(e));
+        const descGhostId = `__ghost_descendants_${n.id}`;
+        if (ghostIds.has(descGhostId)) {
+            filteredEdges.push(descGhostId);
+        }
+        result.push({ ...n, edges: filteredEdges.length > 0 ? filteredEdges : undefined });
+    }
+    for (const gid of ghostIds) {
+        if (gid.startsWith('__ghost_descendants_')) {
+            const boundaryId = gid.replace('__ghost_descendants_', '');
+            const boundaryNode = nodeMap.get(boundaryId);
+            const allChildren = (boundaryNode?.edges ?? []).filter(c => !included.has(c) && nodeMap.has(c));
+            const count = allChildren.length;
+            result.push({
+                id: gid,
+                label: `... ${count} descendant${count !== 1 ? 's' : ''}`,
+                _ghost: true,
+                _ghostLabel: `... ${count} descendant${count !== 1 ? 's' : ''}`,
+            });
+        }
+    }
+    return result;
+}
+// ── dagLayout ──────────────────────────────────────────────────────
+export function dagLayout(nodes, options = {}) {
+    const ctx = resolveCtx(options.ctx);
+    if (nodes.length === 0)
+        return { output: '', nodes: new Map(), width: 0, height: 0 };
+    const result = renderInteractiveLayout(nodes, options, ctx);
+    return { output: result.output, nodes: result.nodes, width: result.width, height: result.height };
+}
+// ── Main Entry Point ───────────────────────────────────────────────
+export function dag(nodes, options = {}) {
+    const ctx = resolveCtx(options.ctx);
+    const mode = ctx.mode;
+    if (nodes.length === 0)
+        return '';
+    if (mode === 'pipe') {
+        return renderPipe(nodes);
+    }
+    if (mode === 'accessible') {
+        const layerMap = assignLayers(nodes);
+        return renderAccessible(nodes, layerMap);
+    }
+    return renderInteractiveLayout(nodes, options, ctx).output;
+}
+//# sourceMappingURL=dag.js.map