flowfig 0.1.0 → 0.3.0

package/dist/svg.js

@@ -10,18 +10,22 @@ import { route } from './geometry.js';
 import { foldedLabel, groupBox, layoutRail, railState, RAIL } from './rail.js';
 import { textWidth } from './text.js';
 import { checkScene, checkSpec, checkTheme } from './check.js';
-import { ASYNC_TAG_W, BASE_RATE, CARD_LINE, CARD_PAD, CARD_WIDTH, DARK, EDGE_OFF, EDGE_ON, LIGHT, TONES, labelPillW, ON_ACCENT, str, edgeId, groupGap, isGroup, isRows, toBeat, } from './model.js';
+export { parseSource, links } from './source.js';
+export { diff, formatDiff } from './diff.js';
+import { ASYNC_TAG_W, BASE_RATE, CARD_LINE, CARD_PAD, CARD_WIDTH, DARK, EDGE_OFF, EDGE_ON, LIGHT, TONES, toneFill, toneTint, labelPillW, ON_ACCENT, str, edgeId, groupGap, isGroup, isRows, toBeat, beatMs, STEP_HOLD_MS, } from './model.js';
 export { LIGHT, DARK } from './model.js';
 const LINE = CARD_LINE, CARD_SIDE = 8, ROW_GAP = 4;
 const LABEL_LINE = 18, SUB_LINE = 15, NODE_MIN_W = 100, NODE_MAX_W = 190;
 const FRAME_TOP = 37, FRAME_SIDE = 18, FRAME_BOTTOM = 18;
-// The card-on fills are fixed colors that approximate the player's 8% accent tint, so the SVG needs no color-mix.
-const vars = (t, cardOn) => `--accent:${t.accent}; --fg:${t.fg}; --muted:${t.muted}; --bg:${t.bg}; --surface:${t.surface}; --border:${t.border}; --card-on:${cardOn};`;
+// The card-on fills are fixed colors that approximate the player's 8% accent tint. The active tint is the player's color-mix.
+const vars = (t, cardOn) => `--accent:${t.accent}; --fg:${t.fg}; --muted:${t.muted}; --bg:${t.bg}; --surface:${t.surface}; --border:${t.border}; --card-on:${cardOn}; --tint:color-mix(in srgb, var(--accent) 10%, var(--surface));`;
 /** What a card actually holds: rows, or its text. Only text survives outside React. */
 const content = (c) => (isRows(c) ? c : str(c));
 const esc = (s) => s.replace(/[<>&"]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;' })[c]);
 const n2 = (v) => Math.round(v * 10) / 10;
-const pct = (v) => n2(v * 100) + '%';
+// Keyframe times are fractions of a loop that can last a minute: one decimal would round a 0.7 s hop away, and the packet would jump.
+const n4 = (v) => Math.round(v * 10000) / 10000;
+const pct = (v) => Math.round(v * 10000) / 100 + '%';
 /** Break a string into lines that fit `width`, keeping the newlines it already has. */
 function wrap(s, width, fontSize, mono = false) {
     const out = [];
@@ -189,17 +193,31 @@ export function render(fig, opts = {}) {
     // The timeline: every beat of every step, in order, with the player's hold at the end of each step.
     const segs = [];
     const hops = [];
+    const edgeOf = Object.fromEntries(fig.edges.map((e, i) => [ids[i], e]));
     let t = 0;
     beats.forEach((stepBeats, si) => {
         stepBeats.forEach((b, bi) => {
-            const dur = (b.ms ?? fig.speed ?? 900) / 1000 / BASE_RATE;
             const last = bi === stepBeats.length - 1;
+            const dur = beatMs(b, opts.speed ?? fig.speed ?? 900) / 1000 / BASE_RATE;
+            const hold = last ? STEP_HOLD_MS / 1000 / BASE_RATE : 0;
             b.hops.forEach((h, lane) => {
                 if (byId[h.edge])
-                    hops.push({ si, bi, lane, edge: h.edge, back: h.back, data: h.data, t0: t, t1: t + dur });
+                    hops.push({
+                        si,
+                        bi,
+                        lane,
+                        edge: h.edge,
+                        dest: h.back ? edgeOf[h.edge].from : edgeOf[h.edge].to,
+                        back: h.back,
+                        data: h.data,
+                        tone: h.tone && TONES[h.tone],
+                        t0: t,
+                        t1: t + speed,
+                        tEnd: t + dur,
+                    });
             });
-            segs.push({ t0: t, t1: t + dur + (last ? speed * 1.5 : 0), si, bi });
-            t += dur + (last ? speed * 1.5 : 0);
+            segs.push({ t0: t, t1: t + dur + hold, si, bi });
+            t += dur + hold;
         });
     });
     const total = t || 1;
@@ -240,8 +258,8 @@ export function render(fig, opts = {}) {
         return list ? ` class="${list}"` : '';
     };
     /** Like `anim`, for a property that takes a different value in each segment (a row that moves as phases fold). */
-    const frames = (values, prefix) => {
-        if (!segs.length || values.every((v) => v === values[0]))
+    const frames = (values, prefix, base = values[0]) => {
+        if (!segs.length || values.every((v) => v === base))
             return '';
         const key = prefix + values.join('|');
         if (!seen.has(key)) {
@@ -252,6 +270,59 @@ export function render(fig, opts = {}) {
         }
         return seen.get(key);
     };
+    /**
+     * The look of one box over the loop: off, trail (visited) or active (the packet arrived, until the segment ends).
+     * A segment ends at the beat end, or after the step hold for the last beat.
+     * Each frame holds one look. The gap before the frame that follows an active frame gives the FADE.
+     * FADE is in timeline seconds, which are wall seconds.
+     */
+    const FADE = 0.4;
+    // A box tone is a permanent state: a 1 px border and a light tint in the off and trail looks. The active look uses the hop tone, else the box tone.
+    const looks = (look, boxTone, hopTone) => {
+        const tint = boxTone ? toneTint(boxTone, 'var(--bg)') : 'var(--bg)';
+        if (look === 'off')
+            return [tint, boxTone ?? 'var(--border)', 1, 'drop-shadow(0 0 0 transparent)'];
+        if (look === 'trail')
+            return [tint, boxTone ?? 'var(--accent)', 1, 'drop-shadow(0 0 0 transparent)'];
+        const c = hopTone ?? boxTone;
+        return c
+            ? [toneTint(c, 'var(--surface)', 10), c, 2, `drop-shadow(0 0 4px ${c})`]
+            : ['var(--tint)', 'var(--accent)', 2, 'drop-shadow(0 0 4px var(--accent))'];
+    };
+    const boxAnim = (id, shape, boxTone) => {
+        const pieces = [];
+        segs.forEach((s, i) => {
+            if (!litNodes[i].has(id))
+                return void pieces.push({ a: s.t0, b: s.t1, look: 'off' });
+            const here = hops.filter((h) => h.dest === id && h.si === s.si && h.bi === s.bi);
+            const arrive = Math.min(...here.map((h) => h.t1), s.t1);
+            if (arrive > s.t0)
+                pieces.push({ a: s.t0, b: arrive, look: 'trail' });
+            if (arrive < s.t1)
+                pieces.push({ a: arrive, b: s.t1, look: 'active', hop: here.find((h) => h.tone)?.tone });
+        });
+        if (!pieces.length || pieces.every((q) => q.look === 'off'))
+            return '';
+        // The last frame is active: the fade ends at 100 %, so the loop wraps with no jump.
+        const end = pieces.at(-1);
+        if (end.look === 'active') {
+            end.b -= FADE;
+            pieces.push({ a: end.b, b: end.b + FADE, look: pieces[0].look, hop: pieces[0].hop, ramp: FADE - 0.0002 * total });
+        }
+        const kf = pieces.map((q, k) => {
+            const ramp = q.ramp ?? (q.look !== 'active' && pieces[k - 1]?.look === 'active' ? Math.min(FADE, (q.b - q.a) / 2) : 0);
+            const [fill, stroke, width, filter] = looks(q.look, boxTone, q.hop);
+            const css = `${shape ? `fill: ${fill}; ` : ''}stroke: ${stroke}; stroke-width: ${width}${shape ? `; filter: ${filter}` : ''}`;
+            return `${pct((q.a + ramp) / total)},${pct(q.b / total - 0.0001)} { ${css} }`;
+        });
+        const key = (shape ? 'B' : 'R') + kf.join(' ');
+        if (!seen.has(key)) {
+            const name = `a${seen.size}`;
+            seen.set(key, name);
+            css.push(`@keyframes ${name} { ${kf.join(' ')} }\n.${name} { animation: ${name} ${n2(total)}s infinite linear; }`);
+        }
+        return seen.get(key);
+    };
     const boxes = placed.map((p) => {
         const { item } = p;
         if (isGroup(item)) {
@@ -262,18 +333,21 @@ export function render(fig, opts = {}) {
                 cls(anim(on, 'stroke: var(--accent)', 'stroke: var(--border)', 'n')) +
                 `/><text x="${n2(p.x + FRAME_SIDE)}" y="${n2(p.y + 20)}" class="frame">${esc(str(item.label).toUpperCase())}</text>`);
         }
-        const on = segs.map((_, i) => litNodes[i].has(item.id));
-        const stroke = cls(anim(on, 'stroke: var(--accent)', 'stroke: var(--border)', 'n'));
+        const bt = item.tone && TONES[item.tone];
+        const stroke = cls(boxAnim(item.id, true, bt));
+        const rim = item.shape === 'store' ? cls(boxAnim(item.id, false, bt)) : '';
+        const fill0 = bt ? toneTint(bt, 'var(--bg)') : 'var(--bg)';
+        const stroke0 = bt ?? 'var(--border)';
         const cx = p.x + p.w / 2;
         const contents = cards.get(item.id);
         const cardTop = p.y + p.h - 10 - (contents ? cardH.get(item.id) : 0);
         const labelY = item.shape === 'store' ? p.y + 24 + 13 : contents ? p.y + 10 + 13 : p.y + p.h / 2 + (item.sub ? -2 : 5);
         const shape = item.shape === 'decision'
-            ? `<polygon points="${n2(cx)},${n2(p.y)} ${n2(p.x + p.w)},${n2(p.y + p.h / 2)} ${n2(cx)},${n2(p.y + p.h)} ${n2(p.x)},${n2(p.y + p.h / 2)}" fill="var(--bg)" stroke="var(--border)"${stroke}/>`
+            ? `<polygon points="${n2(cx)},${n2(p.y)} ${n2(p.x + p.w)},${n2(p.y + p.h / 2)} ${n2(cx)},${n2(p.y + p.h)} ${n2(p.x)},${n2(p.y + p.h / 2)}" fill="${fill0}" stroke="${stroke0}"${stroke}/>`
             : item.shape === 'store'
-                ? `<path d="M${n2(p.x)} ${n2(p.y + 12)} a ${n2(p.w / 2)} 12 0 0 1 ${n2(p.w)} 0 v ${n2(p.h - 24)} a ${n2(p.w / 2)} 12 0 0 1 ${n2(-p.w)} 0 z" fill="var(--bg)" stroke="var(--border)"${stroke}/>` +
-                    `<path d="M${n2(p.x)} ${n2(p.y + 12)} a ${n2(p.w / 2)} 12 0 0 0 ${n2(p.w)} 0" fill="none" stroke="var(--border)"${stroke}/>`
-                : `<rect x="${n2(p.x)}" y="${n2(p.y)}" width="${n2(p.w)}" height="${n2(p.h)}" rx="10" fill="var(--bg)" stroke="var(--border)"${stroke}/>`;
+                ? `<path d="M${n2(p.x)} ${n2(p.y + 12)} a ${n2(p.w / 2)} 12 0 0 1 ${n2(p.w)} 0 v ${n2(p.h - 24)} a ${n2(p.w / 2)} 12 0 0 1 ${n2(-p.w)} 0 z" fill="${fill0}" stroke="${stroke0}"${stroke}/>` +
+                    `<path d="M${n2(p.x)} ${n2(p.y + 12)} a ${n2(p.w / 2)} 12 0 0 0 ${n2(p.w)} 0" fill="none" stroke="${stroke0}"${rim}/>`
+                : `<rect x="${n2(p.x)}" y="${n2(p.y)}" width="${n2(p.w)}" height="${n2(p.h)}" rx="10" fill="${fill0}" stroke="${stroke0}"${stroke}/>`;
         const label = `<text x="${n2(cx)}" y="${n2(labelY)}" class="label">${esc(str(item.label))}</text>`;
         const sub = item.sub ? `<text x="${n2(cx)}" y="${n2(labelY + SUB_LINE)}" class="sub">${esc(str(item.sub))}</text>` : '';
         return shape + label + sub + (contents ? card(p, cardTop, contents) : '');
@@ -338,7 +412,15 @@ export function render(fig, opts = {}) {
         const on = segs.map((_, i) => litEdges[i].has(r.id));
         const hidden = e.quiet && !on.every(Boolean);
         const shown = hidden ? cls(anim(on, 'opacity: 1', 'opacity: 0', 'q')) : '';
-        const lit = cls(anim(on, `stroke: var(--accent); stroke-width: ${EDGE_ON}`, `stroke: var(--muted); stroke-width: ${EDGE_OFF}`, 'e'));
+        // A toned hop colors its edge for its own beat only; the trail after it is the accent.
+        const tone = segs.map(({ si, bi }) => (beats[si][bi].hops.find((h) => h.edge === r.id && h.tone)?.tone ?? undefined));
+        const col = tone.map((x) => (x ? TONES[x] : 'var(--accent)'));
+        const off = `stroke: var(--muted); stroke-width: ${EDGE_OFF}`;
+        // With no tone the map and the rail share one keyframe (same key); a toned edge needs its own values.
+        const toned = tone.some(Boolean);
+        const lit = cls(toned
+            ? frames(on.map((x, i) => (x ? `stroke: ${col[i]}; stroke-width: ${EDGE_ON}` : off)), 'e', off)
+            : anim(on, `stroke: var(--accent); stroke-width: ${EDGE_ON}`, off, 'e'));
         const path = `<path id="p-${esc(r.id)}" d="${r.d}" fill="none" stroke="var(--muted)" stroke-width="${EDGE_OFF}" marker-end="url(#arrow)"${lit}/>`;
         // A quiet edge is only drawn while a step uses it, so wrap the whole thing rather than the stroke.
         const label = e.label == null
@@ -348,17 +430,19 @@ export function render(fig, opts = {}) {
                 labelRects[r.id] = { x: r.mid.x - lw / 2, y: r.mid.y - 9, w: lw, h: 18 };
                 fonts.push(11);
                 return (`<rect x="${n2(r.mid.x - lw / 2)}" y="${n2(r.mid.y - 9)}" width="${n2(lw)}" height="18" rx="9" fill="var(--bg)" stroke="var(--border)"` +
-                    cls(anim(on, 'fill: var(--accent); stroke: var(--accent)', 'fill: var(--bg); stroke: var(--border)', 'l')) +
+                    cls(toned
+                        ? frames(on.map((x, i) => x ? `fill: ${tone[i] ? toneFill(col[i]) : col[i]}; stroke: ${col[i]}` : 'fill: var(--bg); stroke: var(--border)'), 'l', 'fill: var(--bg); stroke: var(--border)')
+                        : anim(on, 'fill: var(--accent); stroke: var(--accent)', 'fill: var(--bg); stroke: var(--border)', 'l')) +
                     `/><text x="${n2(r.mid.x)}" y="${n2(r.mid.y + 4)}"${cls('edgelabel', anim(on, `fill: ${ON_ACCENT}`, 'fill: var(--muted)', 'x'))}>${esc(str(e.label))}</text>`);
             })();
         return hidden ? `<g opacity="0"${shown}>${path}${label}</g>` : path + label;
     });
-    // A packet per hop: it waits offstage, crosses its edge during its beat, then leaves. Any `data`
+    // A packet per hop: it waits offstage, crosses its edge in `speed`, rests at the end of the edge to the end of its beat, then leaves. Any `data`
     // rides above it in a chip, which is how the figure says what is moving.
     const packets = hops.map((h, i) => {
-        const t0 = h.t0 / total, t1 = h.t1 / total;
+        const t0 = h.t0 / total, t1 = h.t1 / total, tEnd = h.tEnd / total;
         const name = `p${i}`;
-        css.push(`@keyframes ${name} { 0%,${pct(t0)} { opacity: 0 } ${pct(t0 + 0.0001)},${pct(t1 - 0.0001)} { opacity: 1 } ${pct(t1)},100% { opacity: 0 } }\n` +
+        css.push(`@keyframes ${name} { 0%,${pct(t0)} { opacity: 0 } ${pct(t0 + 0.0001)},${pct(tEnd - 0.0001)} { opacity: 1 } ${pct(tEnd)},100% { opacity: 0 } }\n` +
             `.${name} { animation: ${name} ${n2(total)}s infinite step-end; }`);
         const chip = (() => {
             const label = str(h.data);
@@ -368,11 +452,11 @@ export function render(fig, opts = {}) {
             const lines = wrap(label, 210, 11.5);
             const w = Math.max(...lines.map((l) => textWidth(l, 11.5))) + 18;
             const boxH = lines.length * 15 + 8;
-            return (`<rect x="${n2(-w / 2)}" y="${n2(-boxH - 12)}" width="${n2(w)}" height="${n2(boxH)}" rx="8" fill="var(--accent)"/>` +
+            return (`<rect x="${n2(-w / 2)}" y="${n2(-boxH - 12)}" width="${n2(w)}" height="${n2(boxH)}" rx="8" fill="${h.tone ? toneFill(h.tone) : 'var(--accent)'}"/>` +
                 lines.map((l, li) => `<text x="0" y="${n2(-boxH - 12 + 15 * li + 15)}" class="chip">${esc(l)}</text>`).join(''));
         })();
-        return (`<g${cls(name)} opacity="0"><circle r="10" fill="var(--accent)" opacity="0.2"/><circle r="4.5" fill="var(--accent)"/>${chip}` +
-            `<animateMotion dur="${n2(total)}s" repeatCount="indefinite" keyTimes="0;${n2(t0)};${n2(t1)};1" keyPoints="${h.back ? '1;1;0;0' : '0;0;1;1'}" calcMode="linear">` +
+        return (`<g${cls(name)} opacity="0"><circle r="10" fill="${h.tone ?? 'var(--accent)'}" opacity="0.2"/><circle r="4.5" fill="${h.tone ?? 'var(--accent)'}"/>${chip}` +
+            `<animateMotion dur="${n2(total)}s" repeatCount="indefinite" keyTimes="0;${n4(t0)};${n4(t1)};1" keyPoints="${h.back ? '1;1;0;0' : '0;0;1;1'}" calcMode="linear">` +
             `<mpath href="#p-${esc(h.edge)}" xlink:href="#p-${esc(h.edge)}"/></animateMotion></g>`);
     });
     const bounds = placed[0];
@@ -461,7 +545,8 @@ export function render(fig, opts = {}) {
                 const next = segs.map((s) => s.si < row.step || (s.si === row.step && s.bi < row.beat));
                 const [x1, x2] = [rail.columns[row.from].x, rail.columns[row.to].x];
                 const ly = y + RAIL.row / 2;
-                const lit = anim(now, `stroke: var(--accent); stroke-width: ${EDGE_ON}`, `stroke: var(--muted); stroke-width: ${EDGE_OFF}`, 'e');
+                const col = row.tone ? TONES[row.tone] : 'var(--accent)';
+                const lit = anim(now, `stroke: ${col}; stroke-width: ${EDGE_ON}`, `stroke: var(--muted); stroke-width: ${EDGE_OFF}`, row.tone ? 'e' + col : 'e');
                 const tagW = ASYNC_TAG_W;
                 // The tag sits on the tail side of the pill, so it never hides the arrowhead.
                 const tagX = !row.pill ? (x1 + x2) / 2 - tagW / 2 : x2 > x1 ? row.pill.x - tagW - 4 : row.pill.x + row.pill.w + 4;
@@ -471,7 +556,7 @@ export function render(fig, opts = {}) {
                         `<text x="${n2(tagX + tagW / 2)}" y="${n2(ly + 3)}" class="tag" fill="${TONES.gray}">ASYNC</text>`
                     : '';
                 const pill = row.pill
-                    ? `<rect x="${n2(row.pill.x)}" y="${n2(ly - 9)}" width="${n2(row.pill.w)}" height="18" rx="9" fill="var(--bg)" stroke="var(--border)"${cls(anim(now, 'fill: var(--accent); stroke: var(--accent)', 'fill: var(--bg); stroke: var(--border)', 'l'))}/>` +
+                    ? `<rect x="${n2(row.pill.x)}" y="${n2(ly - 9)}" width="${n2(row.pill.w)}" height="18" rx="9" fill="var(--bg)" stroke="var(--border)"${cls(anim(now, `fill: ${row.tone ? toneFill(col) : col}; stroke: ${col}`, 'fill: var(--bg); stroke: var(--border)', row.tone ? 'l' + col : 'l'))}/>` +
                         `<text x="${n2(row.pill.x + row.pill.w / 2)}" y="${n2(ly + 4)}"${cls('edgelabel', anim(now, `fill: ${ON_ACCENT}`, 'fill: var(--muted)', 'x'))}>${esc(row.text)}</text>`
                     : '';
                 parts.push(`<g${cls('railrow', moveRow(i))}><g${cls(anim(next, 'opacity: .45', 'opacity: 1', 'r'))}>` +
@@ -505,7 +590,7 @@ svg { ${vars(t0, '#eef5fd')} }
 .end { text-anchor: end; }
 ${css.join('\n')}
 </style>
-<defs><marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M 0 1 L 9 5 L 0 9 z" fill="var(--muted)"/></marker></defs>
+<defs><marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M 0 1 L 9 5 L 0 9 z" fill="context-stroke"/></marker></defs>
 <rect width="100%" height="100%" fill="var(--bg)"/>
 ${only
         ? ''
@@ -541,6 +626,7 @@ ${said.join('\n')}
                 return [
                     {
                         id: `rail:${row.n}`,
+                        step: row.step,
                         from: rail.columns[row.from].id,
                         to: rail.columns[row.to].id,
                         curve: [p, p, q, q],

package/dist/verify.d.ts

@@ -0,0 +1,7 @@
+import type { FlowProps } from './model.ts';
+import type { Finding } from './scene.ts';
+export { parseSource, headingSlug, owners, links, type Link } from './source.ts';
+/** The links against the files under `root`. A path outside the root is a missing file: the figure names the repo, not the disk. */
+export declare function verify(fig: FlowProps, { root }?: {
+    root?: string;
+}): Finding[];

package/dist/verify.js

@@ -0,0 +1,43 @@
+// `flowfig verify`: checks that the code a link names is still there. The link parsing lives in source.ts, which has no Node import.
+import { readFileSync, statSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { headingSlug, links } from './source.js';
+export { parseSource, headingSlug, owners, links } from './source.js';
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** The file text, or null for a missing path, a folder or an unreadable file. */
+function read(full) {
+    try {
+        return statSync(full).isFile() ? readFileSync(full, 'utf8') : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** True if a heading line of the Markdown text has this slug. */
+const hasHeading = (text, slug) => text.split('\n').some((line) => {
+    const m = /^#{1,6}\s+(.*?)\s*#*\s*$/.exec(line);
+    return m != null && headingSlug(m[1]) === slug;
+});
+/** The links against the files under `root`. A path outside the root is a missing file: the figure names the repo, not the disk. */
+export function verify(fig, { root = process.cwd() } = {}) {
+    const out = [];
+    const all = links(fig);
+    if (!all.length)
+        return [{ rule: 'no-source', severity: 'warning', ids: [], message: 'no box, edge or hop has a source' }];
+    const files = new Map();
+    for (const l of all) {
+        const full = resolve(root, l.path);
+        const rel = relative(root, full);
+        const outside = isAbsolute(l.path) || rel === '..' || rel.startsWith('../');
+        if (!files.has(full))
+            files.set(full, outside ? null : read(full));
+        const text = files.get(full);
+        if (text == null)
+            out.push({ rule: 'missing-file', severity: 'error', ids: [], message: `${l.owner} -> ${l.source}: file not found` });
+        else if (l.symbol &&
+            !new RegExp(`(^|[^\\w$])${escape(l.symbol)}(?![\\w$])`).test(text) &&
+            !(/\.(md|markdown)$/i.test(l.path) && hasHeading(text, l.symbol)))
+            out.push({ rule: 'missing-symbol', severity: 'error', ids: [], message: `${l.owner} -> ${l.source}: symbol not found` });
+    }
+    return out;
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** The package version, for the MCP `serverInfo`. The release list bumps it with package.json. */
+export declare const VERSION = "0.3.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+/** The package version, for the MCP `serverInfo`. The release list bumps it with package.json. */
+export const VERSION = '0.3.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowfig",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Your coding agent draws animated diagrams from your code, and flowfig checks them. One animated SVG for a GitHub README, PR or issue, and a React player. Set up Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, Windsurf and Kiro with npx flowfig init.",
   "license": "MIT",
   "repository": {
@@ -40,6 +40,10 @@
     "./svg": {
       "types": "./dist/svg.d.ts",
       "default": "./dist/svg.js"
+    },
+    "./verify": {
+      "types": "./dist/verify.d.ts",
+      "default": "./dist/verify.js"
     }
   },
   "bin": {