flowfig 0.8.4 → 0.10.0

package/dist/cli.js

@@ -18,24 +18,32 @@ import { GUIDE, TOPICS } from './guide.js';
 import { runDraw } from './draw.js';
 import { runInit } from './init.js';
 import { serve } from './mcp.js';
+import { runAtlas } from './atlas.js';
+import { runFromMermaid } from './mermaid.js';
 import { openedLine, openSvg, runOpen } from './open.js';
 import { pageHtml } from './page.js';
 import { decodePng } from './png.js';
-import { diff, formatDiff } from './diff.js';
+import { diff, formatDiff, mergeFigures } from './diff.js';
 import { loadSpec, reportLines, sortFindings, specOf, summaryLines, svgWithSpec, verifyLines } from './load.js';
 import { check, render, toSvg } from './svg.js';
 import { checkRendered } from './check.js';
-import { coverageLine, links, unsureLines, verifyReport } from './verify.js';
+import { coverageLine, links, parseSource, unsureLines, verifyReport } from './verify.js';
+import { trace, traceLines } from './trace.js';
+import { coverageLines, coverageReport } from './coverage.js';
 const USAGE = `usage: flowfig <-|spec.json|figure.ts> [out.svg] [--open]   render a figure; a spec on stdin with -
        flowfig check <-|spec.json|figure.ts|figure.svg>   list the faults; the input can be an SVG this wrote
        flowfig --spec figure.svg                          print the spec the SVG carries
        flowfig verify <input>... [--root <dir>] [--json] [--strict]   check the code links of one or more figures
-       flowfig diff <old> <new> [--json|--md]   list the spec changes between two figures
+       flowfig diff <old> <new> [--json|--md] [--svg <out.svg>]   list the spec changes between two figures, or draw them in one SVG
+       flowfig trace <file#symbol> [--depth <n>] [--max <n>] [--root <dir>] [--json]   list the calls under a symbol, each one checked
+       flowfig coverage [--figures <glob>] [--entries <glob>] [--root <dir>] [--strict] [--json]   list failing and stale figures, and code with no figure
        flowfig docs [topic]                               print the guide, or one topic (Markdown)
        flowfig mcp                                        serve check, render, verify, diff and docs over MCP (stdio)
-       flowfig init [dir] [--agents <ids>] [-y] [--global] [--dry-run] [--no-mcp]   write flowfig instructions for the coding agents of a repo
+       flowfig init [dir] [--agents <ids> | --all-agents | --list-agents] [-y] [--global] [--dry-run] [--no-mcp]   write flowfig instructions for the coding agents of a repo
        flowfig draw "<question>" [--out <path>] [--model <alias>] [--max-turns <n>] [--json] [--open]   ask Claude Code for a figure, then check it
+       flowfig atlas [--figures <glob>] [--root <dir>] [--out <dir>] [--open]   write one linked web page for each figure, and an index
        flowfig open <figure.svg> [--html <path>]          show the figure in the default browser
+       flowfig from-mermaid <file.mmd|file.md|-> [--out <dir>]   convert Mermaid diagrams to specs
        flowfig gif <figure.svg> [out.gif] [--step <n>] [--dark] [--fps <n>] [--scale <n>] [--mp4]   write an animated GIF
 flags for render and check: --strict (warnings are errors), --json, --width <px>, --min-text <px>, --no-check (render only), --no-verify (render only)`;
 function usage(message) {
@@ -54,6 +62,10 @@ const value = (name) => {
     const n = Number(args.splice(i, 2)[1] || NaN);
     return n > 0 && Number.isFinite(n) ? n : usage(`${name} needs a positive number`);
 };
+const option = (name) => {
+    const i = args.indexOf(name);
+    return i === -1 ? undefined : (args.splice(i, 2)[1] ?? usage(`${name} needs a value`));
+};
 if (!args[0] || ['help', '--help', '-h'].includes(args[0])) {
     if (args[0])
         console.log(USAGE);
@@ -78,8 +90,12 @@ if (args[0] === 'init')
     process.exit(await runInit(args.slice(1)));
 if (args[0] === 'draw')
     process.exit(await runDraw(args.slice(1)));
+if (args[0] === 'atlas')
+    process.exit(await runAtlas(args.slice(1)));
 if (args[0] === 'open')
     process.exit(await runOpen(args.slice(1)));
+if (args[0] === 'from-mermaid')
+    process.exit(runFromMermaid(args.slice(1)));
 if (args[0] === '--spec') {
     if (!args[1])
         usage('--spec needs the path of an SVG');
@@ -148,15 +164,62 @@ if (args[0] === 'verify') {
     }
     process.exit(errors ? 1 : 0);
 }
+if (args[0] === 'trace') {
+    args.shift();
+    const json = flag('--json');
+    const depth = value('--depth') ?? 2, max = value('--max') ?? 40;
+    if (!Number.isInteger(depth) || !Number.isInteger(max))
+        usage('--depth and --max need a whole number');
+    const root = resolve(option('--root') ?? '.');
+    const unknown = args.find((a) => a.startsWith('-'));
+    if (unknown)
+        usage(`unknown flag ${unknown}`);
+    if (args.length !== 1 || !parseSource(args[0])?.symbol)
+        usage('usage: flowfig trace <file#symbol> [--depth <n>] [--max <n>] [--root <dir>] [--json]');
+    try {
+        const r = trace(args[0], { root, depth, max });
+        console.log(json ? JSON.stringify(r, null, 2) : traceLines(r, depth, max).join('\n'));
+    }
+    catch (e) {
+        console.error(`trace: ${e.message}`);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+if (args[0] === 'coverage') {
+    args.shift();
+    const json = flag('--json'), strict = flag('--strict');
+    const root = resolve(option('--root') ?? '.');
+    const figures = option('--figures'), entries = option('--entries');
+    const unknown = args.find((a) => a.startsWith('-'));
+    if (unknown)
+        usage(`unknown flag ${unknown}`);
+    if (args.length)
+        usage('usage: flowfig coverage [--figures <glob>] [--entries <glob>] [--root <dir>] [--strict] [--json]');
+    if (!existsSync(root))
+        usage(`${root}: the folder does not exist`);
+    const r = coverageReport({ root, figures, entries });
+    console.log(json ? JSON.stringify(r, null, 2) : coverageLines(r).join('\n'));
+    process.exit(strict && r.figures.some((f) => f.state === 'fail' || f.state === 'stale') ? 1 : 0);
+}
 if (args[0] === 'diff') {
     args.shift();
     const json = flag('--json'), md = flag('--md');
+    const svgOut = option('--svg');
     const unknown = args.find((a) => a.startsWith('-') && a !== '-');
     if (unknown)
         usage(`unknown flag ${unknown}`);
     if (args.length !== 2)
-        usage('diff needs two figures: flowfig diff <old> <new> [--json|--md]');
-    const changes = diff(await load(args[0]), await load(args[1]));
+        usage('diff needs two figures: flowfig diff <old> <new> [--json|--md] [--svg <out.svg>]');
+    const [before, after] = [await load(args[0]), await load(args[1])];
+    const changes = diff(before, after);
+    if (svgOut) {
+        const { figure, marks } = mergeFigures(before, after);
+        const { svg, scene } = render(figure, { marks });
+        for (const f of sortFindings(checkRendered(figure, {}, scene), false))
+            console.error(`${f.severity.padEnd(8)} ${f.rule.padEnd(18)} ${f.message}`);
+        writeFileSync(svgOut, svg);
+    }
     console.log(json ? JSON.stringify(changes, null, 2) : formatDiff(changes, md ? 'md' : 'text'));
     process.exit(0);
 }

package/dist/code.d.ts

@@ -16,6 +16,8 @@ type Extent = [number, number];
 export declare const esc: (s: string) => string;
 export declare function matchClose(code: string, open: number): number;
 export declare function pyBody(code: string, start: number): Extent;
+export declare function depthAt(code: string, pos: number, lo: number): number;
+export declare const definitions: (file: CodeFile, name: string, lo?: number, hi?: number) => number;
 export declare function outside(root: string, path: string): boolean;
 export declare function codeFile(root: string, path: string, read?: Read, cache?: Map<string, CodeFile | null>): CodeFile | null;
 export declare const locate: (file: CodeFile, symbol: string) => {

package/dist/code.js

@@ -371,7 +371,7 @@ function defPatterns(lang, name, inContainer) {
     }
 }
 const KEYWORDS = new Set(['if', 'for', 'while', 'switch', 'catch', 'return', 'new', 'await', 'typeof', 'else', 'do', 'throw']);
-function depthAt(code, pos, lo) {
+export function depthAt(code, pos, lo) {
     let d = 0;
     for (let i = lo; i < pos; i++) {
         if (code[i] === '{')
@@ -400,12 +400,12 @@ function pyMemberIndent(code, lo, hi) {
     }
     return min;
 }
-function findIn(code, lang, name, lo, hi, member, receiver) {
+function hitsIn(code, lang, name, lo, hi, member, receiver) {
+    const hits = [];
     if (KEYWORDS.has(name) && !/^(rs|py|go)$/.test(lang))
-        return null;
+        return hits;
     const inContainer = member != null;
     const memberIndent = inContainer && lang === 'py' ? pyMemberIndent(code, lo, hi) : -1;
-    const hits = [];
     const pats = defPatterns(lang, name, inContainer);
     for (const re of pats) {
         re.lastIndex = lo;
@@ -465,6 +465,11 @@ function findIn(code, lang, name, lo, hi, member, receiver) {
             hits.push({ start, end: ext[1], depth });
         }
     }
+    return hits;
+}
+export const definitions = (file, name, lo = 0, hi = file.code.length) => new Set(hitsIn(file.code, file.lang, name, lo, hi, null).map((h) => h.start)).size;
+function findIn(code, lang, name, lo, hi, member, receiver) {
+    const hits = hitsIn(code, lang, name, lo, hi, member, receiver);
     if (!hits.length)
         return null;
     hits.sort((a, b) => a.depth - b.depth || a.start - b.start);

package/dist/coverage.d.ts

@@ -0,0 +1,27 @@
+export type FigureState = 'fail' | 'stale' | 'ok' | 'none';
+export type FigureHealth = {
+    figure: string;
+    state: FigureState;
+    detail: string;
+};
+export type CoverageReport = {
+    figures: FigureHealth[];
+    git: boolean;
+    entries?: {
+        glob: string;
+        total: number;
+        uncovered: string[];
+    };
+    folders?: {
+        folder: string;
+        covered: number;
+        total: number;
+    }[];
+};
+export type CoverageOptions = {
+    root?: string;
+    figures?: string;
+    entries?: string;
+};
+export declare function coverageReport({ root, figures, entries }?: CoverageOptions): CoverageReport;
+export declare function coverageLines(r: CoverageReport): string[];

package/dist/coverage.js

@@ -0,0 +1,116 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { posix, resolve } from 'node:path';
+import { langOf, readFile } from './code.js';
+import { loadSpec, specOf } from './load.js';
+import { detailFindings, links, SPEC_MARK, verifyReport } from './verify.js';
+const globRe = (glob) => new RegExp(`^${glob
+    .replace(/^\.\//, '')
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*\/|\*\*|\*|\?/g, (t) => (t === '**/' ? '(?:.*/)?' : t === '**' ? '.*' : t === '*' ? '[^/]*' : '[^/]'))}$`);
+const isTest = (p) => /(^|\/)(__tests__|tests|src\/test)\//.test(p) || /\.(test|spec)\.[^/]+$|(^|\/)test_[^/]*\.py$|_test\.(py|go)$|Tests?\.(java|cs)$/.test(p);
+const day = (t) => (t === Infinity ? 'now' : new Date(t * 1000).toISOString().slice(0, 10));
+const count = (k, word) => `${k} ${word}${k === 1 ? '' : 's'}`;
+function gitTimes(root) {
+    const git = (...a) => execFileSync('git', a, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    try {
+        const prefix = git('rev-parse', '--show-prefix').trim();
+        const dirty = new Set(git('status', '--porcelain', '-z', '--no-renames', '--untracked-files=all')
+            .split('\0')
+            .map((l) => l.slice(3))
+            .filter((p) => p && p.startsWith(prefix))
+            .map((p) => p.slice(prefix.length)));
+        const memo = new Map();
+        return (path) => {
+            if (dirty.has(path))
+                return Infinity;
+            if (!memo.has(path))
+                memo.set(path, Number(git('log', '-1', '--format=%ct', '--', path).trim()) || 0);
+            return memo.get(path);
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function coverageReport({ root = process.cwd(), figures = '**/*.svg', entries } = {}) {
+    const all = readFile.files(root).filter((p) => !p.split('/').includes('dist'));
+    const want = globRe(figures);
+    const time = gitTimes(root);
+    const cache = new Map();
+    const covered = new Set();
+    const out = [];
+    for (const figure of all.filter((p) => p.endsWith('.svg') && want.test(p))) {
+        const text = readFileSync(resolve(root, figure), 'utf8');
+        if (!text.includes(SPEC_MARK))
+            continue;
+        let fig;
+        try {
+            fig = loadSpec(JSON.parse(specOf(text, figure)), figure);
+        }
+        catch (e) {
+            out.push({ figure, state: 'fail', detail: `bad spec: ${e.message}` });
+            continue;
+        }
+        const paths = [...new Set(links(fig).map((l) => posix.normalize(l.path)))];
+        paths.forEach((p) => covered.add(p));
+        const lost = detailFindings(fig, root).length;
+        const lostText = lost ? `; ${lost} missing-detail` : '';
+        if (!paths.length) {
+            out.push({ figure, state: 'none', detail: `no source links${lostText}` });
+            continue;
+        }
+        const { findings, coverage } = verifyReport(fig, { root, cache });
+        const errors = findings.filter((f) => f.severity === 'error');
+        if (errors.length) {
+            out.push({
+                figure,
+                state: 'fail',
+                detail: `${count(errors.length, 'error')}: ${[...new Set(errors.map((f) => f.rule))].join(', ')}`,
+            });
+            continue;
+        }
+        const mine = time?.(figure) || Infinity;
+        const newer = time && paths.find((p) => time(p) > mine);
+        out.push(newer
+            ? { figure, state: 'stale', detail: `${newer} changed ${day(time(newer))}, figure ${day(mine)}` }
+            : { figure, state: 'ok', detail: `${coverage.boxesDefined} of ${coverage.boxes} boxes defined${lostText}` });
+    }
+    const code = all.filter((p) => langOf(p) != null && !isTest(p));
+    const report = { figures: out, git: time != null };
+    if (entries) {
+        const re = globRe(entries);
+        const named = entries.replace(/^\.\//, '');
+        const matched = all.filter((p) => langOf(p) != null && re.test(p) && (p === named || !isTest(p)));
+        report.entries = { glob: entries, total: matched.length, uncovered: matched.filter((p) => !covered.has(p)) };
+    }
+    else {
+        const by = new Map();
+        for (const p of code) {
+            const folder = p.includes('/') ? p.slice(0, p.indexOf('/')) : '.';
+            const row = by.get(folder) ?? { folder, covered: 0, total: 0 };
+            row.total++;
+            if (covered.has(p))
+                row.covered++;
+            by.set(folder, row);
+        }
+        report.folders = [...by.values()];
+    }
+    return report;
+}
+export function coverageLines(r) {
+    const width = Math.max(0, ...r.figures.map((f) => f.figure.length));
+    const tally = (s) => r.figures.filter((f) => f.state === s).length;
+    return [
+        ...(r.git ? [] : ['no git: stale is not checked']),
+        ...r.figures.map((f) => `${f.figure.padEnd(width + 4)}${f.state.padEnd(8)}${f.detail}`),
+        ...(r.entries
+            ? [
+                `uncovered ${r.entries.glob}: ${r.entries.uncovered.length} of ${r.entries.total} files have no figure`,
+                ...r.entries.uncovered.map((p) => `  ${p}`),
+            ]
+            : []),
+        ...(r.folders ?? []).map((f) => `code ${f.folder}: ${f.covered} of ${f.total} files have a figure`),
+        `summary: ${count(r.figures.length, 'figure')}: ${tally('ok')} ok, ${tally('stale')} stale, ${tally('fail')} fail, ${tally('none')} none`,
+    ];
+}

package/dist/diff.d.ts

@@ -7,3 +7,13 @@ export type Change = {
 };
 export declare function diff(before: FlowProps, after: FlowProps): Change[];
 export declare function formatDiff(changes: Change[], as: 'text' | 'md'): string;
+export type DiffMark = 'added' | 'removed' | 'changed';
+export type DiffMarks = {
+    boxes: Record<string, DiffMark>;
+    edges: Record<string, DiffMark>;
+    steps: number;
+};
+export declare function mergeFigures(before: FlowProps, after: FlowProps): {
+    figure: FlowProps;
+    marks: DiffMarks;
+};

package/dist/diff.js

@@ -1,4 +1,4 @@
-import { edgeId, isGroup, str, toBeat } from './model.js';
+import { edgeId, isGroup, laneColumns, nodes, str, toBeat } from './model.js';
 const show = (v) => (v == null ? '(none)' : `"${str(v)}"`);
 const fields = (a, b, names) => names.filter((k) => str(a[k]) !== str(b[k])).map((k) => `${String(k)} ${show(a[k])} -> ${show(b[k])}`);
 function compare(kind, before, after, fieldsOf) {
@@ -29,13 +29,13 @@ const messages = (fig) => {
     })));
     return new Map(ids.map((id) => [id, id]));
 };
+const boxes = (f) => {
+    const m = new Map();
+    const walk = (g, parent) => g.children.forEach((c) => (isGroup(c) ? walk(c, c.label != null ? str(c.label) : c.id) : m.set(c.id, { ...c, group: parent })));
+    walk(f.layout);
+    return m;
+};
 export function diff(before, after) {
-    const boxes = (f) => {
-        const m = new Map();
-        const walk = (g, parent) => g.children.forEach((c) => (isGroup(c) ? walk(c, c.label != null ? str(c.label) : c.id) : m.set(c.id, { ...c, group: parent })));
-        walk(f.layout);
-        return m;
-    };
     const edges = (f) => new Map(f.edges.map((e) => [edgeId(e), e]));
     const steps = (f) => new Map((f.steps ?? []).map((s) => [str(s.label), s]));
     const out = [
@@ -60,3 +60,133 @@ export function formatDiff(changes, as) {
     })
         .join('\n');
 }
+const key = (g) => g.id ?? (g.label != null ? str(g.label) : undefined);
+const cloneGroup = (g) => ({ ...g, children: g.children.map((c) => (isGroup(c) ? cloneGroup(c) : c)) });
+const ids = (g) => (isGroup(g) ? nodes(g).map((n) => n.id) : [g.id]);
+function find(root, hit) {
+    for (const [i, c] of root.children.entries()) {
+        if (hit(c))
+            return { parent: root, i };
+        const inner = isGroup(c) ? find(c, hit) : undefined;
+        if (inner)
+            return inner;
+    }
+}
+export function mergeFigures(before, after) {
+    const was = boxes(before);
+    const now = boxes(after);
+    const gone = (c) => ids(c).every((id) => !now.has(id));
+    const layout = cloneGroup(after.layout);
+    const placed = new Set();
+    const locate = (c) => find(layout, (x) => x === c || (isGroup(c) ? isGroup(x) && key(c) != null && key(x) === key(c) : !isGroup(x) && x.id === c.id));
+    const put = (item, frames, sibs, at) => {
+        const sides = [
+            ...sibs
+                .slice(0, at)
+                .reverse()
+                .map((s) => [s, 1]),
+            ...sibs.slice(at + 1).map((s) => [s, 0]),
+        ];
+        const next = after.layout.auto
+            ? undefined
+            : sides
+                .filter(([s]) => placed.has(s) || !gone(s))
+                .map(([s, off]) => ({ spot: locate(s), off }))
+                .find((x) => x.spot);
+        if (next)
+            next.spot.parent.children.splice(next.spot.i + next.off, 0, item);
+        else {
+            const frame = frames.map(locate).find(Boolean);
+            (frame ? frame.parent.children[frame.i] : layout).children.push(item);
+        }
+        placed.add(item);
+    };
+    const walk = (g, frames) => g.children.forEach((c, i, sibs) => {
+        if (isGroup(c) && !(c.label != null && gone(c) && !locate(c)))
+            walk(c, [c, ...frames]);
+        else if (gone(c))
+            put(c, frames, sibs, i);
+    });
+    walk(before.layout, [before.layout]);
+    const marks = { boxes: {}, edges: {}, steps: diff(before, after).filter((c) => c.kind !== 'box' && c.kind !== 'edge').length };
+    for (const [id, n] of now) {
+        const old = was.get(id);
+        if (!old)
+            marks.boxes[id] = 'added';
+        else if (fields(old, n, ['label', 'sub', 'shape', 'source', 'group']).length)
+            marks.boxes[id] = 'changed';
+    }
+    for (const id of was.keys())
+        if (!now.has(id))
+            marks.boxes[id] = 'removed';
+    const colAt = new Map();
+    if (after.lanes) {
+        const colsAfter = laneColumns(after);
+        const colsBefore = laneColumns(before);
+        const kept = [...now.keys()].filter((id) => was.has(id));
+        const slots = new Map();
+        for (const id of was.keys()) {
+            if (now.has(id))
+                continue;
+            const old = colsBefore.get(id);
+            const prev = kept
+                .filter((k) => colsBefore.get(k) < old)
+                .sort((a, b) => colsBefore.get(b) - colsBefore.get(a) || colsAfter.get(b) - colsAfter.get(a));
+            slots.set(id, { p: prev.length ? colsAfter.get(prev[0]) : -1, old });
+        }
+        const groups = [...new Map([...slots.values()].map((v) => [`${v.p}:${v.old}`, v])).values()].sort((a, b) => a.p - b.p || a.old - b.old);
+        for (const id of now.keys())
+            colAt.set(id, colsAfter.get(id) + groups.filter((g) => g.p < colsAfter.get(id)).length);
+        for (const [id, v] of slots) {
+            const i = groups.findIndex((g) => g.p === v.p && g.old === v.old);
+            colAt.set(id, v.p + 1 + groups.filter((g) => g.p < v.p).length + groups.slice(0, i).filter((g) => g.p === v.p).length);
+        }
+    }
+    const paint = (g) => ({
+        ...g,
+        children: g.children.map((c) => {
+            if (isGroup(c))
+                return paint(c);
+            const n = { ...c };
+            delete n.tone;
+            if (after.lanes)
+                n.at = colAt.get(c.id);
+            const old = was.get(c.id);
+            if (marks.boxes[c.id] === 'changed' && old) {
+                if (str(old.label) !== str(c.label))
+                    n.sub = `was "${str(old.label)}"`;
+                else if (old.group !== now.get(c.id).group)
+                    n.sub = old.group != null ? `was in "${old.group}"` : 'moved';
+            }
+            return n;
+        }),
+    });
+    const oldEdges = new Map(before.edges.map((e) => [edgeId(e), e]));
+    const newEdges = new Map(after.edges.map((e) => [edgeId(e), e]));
+    const same = (a, b) => b != null && a.from === b.from && a.to === b.to;
+    const edges = after.edges.map((e) => {
+        const id = edgeId(e);
+        const old = oldEdges.get(id);
+        if (!same(e, old))
+            marks.edges[id] = 'added';
+        else if (fields(old, e, ['label', 'source']).length) {
+            marks.edges[id] = 'changed';
+            if (str(old.label) !== str(e.label) && old.label != null)
+                return { ...e, label: e.label != null ? `${str(e.label)} (was ${str(old.label)})` : `(was ${str(old.label)})` };
+        }
+        return e;
+    });
+    for (const [id, e] of oldEdges) {
+        if (same(e, newEdges.get(id)))
+            continue;
+        const mid = newEdges.has(id) ? `${id} (old)` : id;
+        marks.edges[mid] = 'removed';
+        const gone = { ...e, id: mid };
+        delete gone.around;
+        edges.push(gone);
+    }
+    const figure = { ...after, layout: paint(layout), edges };
+    delete figure.steps;
+    delete figure.rail;
+    return { figure, marks };
+}

package/dist/edges.d.ts

@@ -1,6 +1,9 @@
 import { type CodeFile, type Lang, type Read } from './code.ts';
 export type EdgeResult = 'found' | 'not-found' | 'unsure' | 'not-checked';
 export declare const EDGE_LANGS: ReadonlySet<Lang>;
+export declare function params(body: string, from: string | undefined): string[];
+export declare function paramName(p: string, lang: Lang): string | undefined;
+export declare function shadows(body: string, name: string, lang: Lang, fromName: string | undefined, whole: boolean): boolean;
 export declare function edgeResult(root: string, caller: string, callee: string | undefined, via: string | undefined, read?: Read, cache?: Map<string, CodeFile | null>): {
     result: EdgeResult;
     reason: string;

package/dist/edges.js

@@ -90,7 +90,7 @@ function typedName(body, n) {
     }
     return false;
 }
-function params(body, from) {
+export function params(body, from) {
     const open = body.indexOf('(', from ? Math.max(0, body.indexOf(from)) : 0);
     if (open < 0)
         return [];
@@ -110,7 +110,7 @@ function params(body, from) {
     }
     return [...parts, text.slice(last)];
 }
-function paramName(p, lang) {
+export function paramName(p, lang) {
     const tokens = (p.split('=')[0].match(/[\w$]+/g) ?? []).filter((t) => !MODIFIERS.has(t));
     return lang === 'java' || lang === 'cs' ? tokens.at(-1) : tokens[0];
 }
@@ -123,7 +123,7 @@ function paramCall(body, lang, fromName) {
         .map((p) => paramName(p, lang))
         .find((n) => n && new RegExp(`(?<![\\w$.])${esc(n)}\\s*\\(`).test(rest));
 }
-function shadows(body, name, lang, fromName, whole) {
+export function shadows(body, name, lang, fromName, whole) {
     const n = esc(name);
     if (!whole)
         for (const p of params(body, fromName))

package/dist/geometry.d.ts

@@ -30,6 +30,7 @@ export type Routed = {
     room?: number;
     /** The px an elbow detour goes outside the boxes, for each side. */
     bleed?: Partial<Record<Around, number>>;
+    ends?: [string, string];
 };
 /** A rect that a route keeps clear of. `box` marks a box. */
 export type Avoid = Rect & {
@@ -37,6 +38,7 @@ export type Avoid = Rect & {
 };
 export declare const avoidOf: (boxes: Rect[], extra: Rect[], lanes: boolean) => Avoid[];
 type Around = 'above' | 'below' | 'left' | 'right';
+export declare const samples: (curve: [Pt, Pt, Pt, Pt]) => Pt[];
 export declare const hit: (curve: [Pt, Pt, Pt, Pt], boxes: Rect[], m: number) => Rect[];
 /** Routes edges between measured boxes as curved SVG paths. `elbow` draws right-angle paths; `stub` splits a cross-lane edge in two. */
 export declare function route(edges: {
@@ -46,6 +48,7 @@ export declare function route(edges: {
     around?: Around;
     sides?: [Side, Side];
     elbow?: boolean;
+    drop?: boolean;
     stub?: number[];
     bands?: [Rect | undefined, Rect | undefined];
     labelW?: number;
@@ -53,6 +56,7 @@ export declare function route(edges: {
     bands: Rect[];
     boxes: Rect[];
 }, pad?: number): Routed[];
+export declare const markSide: (id: string, mark: 'start' | 'end', routed: Routed[]) => Side;
 export declare const arcRoom: (routed: Routed[], way: Around) => number;
 export declare function labelAlong(r: Routed, w: number, boxes: Rect[], placed: Rect[], fig?: Rect, lines?: Pt[]): Pt;
 /** True if segment a-b crosses c-d. The ends of a-b are trimmed by 1.5 px. */