flowfig 0.1.0 → 0.2.0

package/dist/guide.js

@@ -63,6 +63,7 @@ If the code does not show a fact, leave the fact out. Do not guess a part, a nam
 
 Each fact becomes a box, an edge, a beat, a \`data\` card or a \`show\` row. Use the real names from the code as labels, and
 real example data from the code or its tests. Keep each fact that you leave out, with the reason, for the reply.
+Give each box and edge that draws code a \`source\`, from the fact list: \`"src/auth/login.ts#verifyPassword"\`. A store or an outside part may have none.
 
 Mermaid mapping:
 
@@ -89,8 +90,10 @@ command writes no SVG and lists the faults. Fix each fault and render again.
 
 - Fix a layout fault by changing the layout first: put parts in rows or columns, route an edge \`around\`, or change a gap.
   Never remove a fact from the fact list to pass the check. If you must remove one, name it in the reply.
-- If \`small-text\` appears, the figure is too wide. Shorten labels, or split the figure. Use more steps in one figure before
-  you make a second figure. Do not change \`--width\` to pass the check: the reader sees the figure at the real page width.
+- If \`small-text\` appears, the figure is too wide. Put the parts in two rows, move a detail from \`label\` to \`sub\`, or split
+  the figure. Use more steps in one figure before you make a second figure. Keep the real name from the code in the label:
+  \`ReportsController\` stays \`ReportsController\`, not \`Controller\`. Do not change \`--width\` to pass the check: the
+  reader sees the figure at the real page width.
 - Fix every other warning, or tell the user why it stays.
 - Do not use \`--no-check\` to hide a fault.
 
@@ -99,6 +102,8 @@ command writes no SVG and lists the faults. Fix each fault and render again.
 Run \`npx flowfig --spec out.svg\`. Compare the spec with the fact list. Check that each edge goes from the caller to the callee
 that its fact names. Add each fact that is missing, fix each wrong edge, and render again.
 
+Run \`npx flowfig verify out.svg\` from the repo root. Fix each \`missing-file\` or \`missing-symbol\`.
+
 ### 6. Look at the SVG
 
 The check estimates the text width, so it cannot see everything. If you can open a browser, open the SVG and take a
@@ -115,7 +120,8 @@ The reply has these parts, in this order:
    from the read-back spec. Never count from memory;
 3. the scope: the flow you drew, why, and the other flows that exist;
 4. what the figure leaves out, and why;
-5. the check line, exactly as the command printed it, and whether you looked at the SVG.
+5. the two check lines that the render printed, \`0 errors, 0 warnings\` and \`figure: ...\`, copied as printed, and whether
+   you looked at the SVG.
 
 To change an SVG later, print its spec with \`--spec\`, change the spec, and render again.
 
@@ -151,6 +157,7 @@ Every other item is a box.
 | \`sub\`     | A smaller line under the label.                                                                           |
 | \`shape\`   | \`"box"\` (default), \`"decision"\` (a diamond) or \`"store"\` (a database cylinder for data at rest).          |
 | \`width\`   | Width in px. This overrides the width that the layout picks.                                              |
+| \`source\`  | The code this draws: \`path\` or \`path#symbol\`, relative to the repo root. \`flowfig verify\` checks it.  |
 | \`lines\`   | The least number of text lines that a content card keeps. The card still grows to fit its content.        |
 
 ### edges
@@ -162,6 +169,7 @@ An edge has these fields.
 - \`label\`: text on the edge, drawn as a small pill.
 - \`around\`: \`"above"\` or \`"below"\`. This routes the edge over or under the boxes in between (loops, skip-ahead edges).
 - \`quiet\`: if \`true\`, the SVG draws the edge only while a step uses it.
+- \`source\`: the code this edge draws, as \`path\` or \`path#symbol\`. \`flowfig verify\` checks it.
 
 ### steps
 
@@ -176,7 +184,7 @@ boxes to highlight for the whole step).
 
 The beat fields:
 
-- \`edges\`: an edge id, a hop object, or an array of these. A hop object is \`{ edge, back?, data?, async? }\`.
+- \`edges\`: an edge id, a hop object, or an array of these. A hop object is \`{ edge, back?, data?, async?, source? }\`.
   - \`back: true\` runs the packet from the \`to\` box to the \`from\` box.
   - \`data\` is a small card that moves with the packet.
   - \`async: true\` marks a message that does not wait for an answer. The rail draws it dashed, with an \`async\` tag.
@@ -199,7 +207,11 @@ A row of a content card is \`{ tag?, tone?, text, meta?, mark?, mono? }\`.
 - Give every box a stable \`id\`.
 - Use \`shape: "store"\` for data at rest (a database, a cache, a file, a queue). Use a plain box for a part that does work. Use \`shape: "decision"\` for a branch.
 - Keep one clear main path, left to right. Put side parts in a \`column\` group.
-- Use \`quiet: true\` on a long edge that crosses the picture.
+- Use \`quiet: true\` on a long edge that crosses the picture. A quiet edge needs a beat that uses it, or the check reports
+  \`hidden-edge\`.
+- In a rail, draw an error reply as a hop back on the same edge, with the error in \`data\` (\`{ "edge": "login", "back": true,
+  "data": "401 CREDENTIALS_INVALID" }\`). A call that stays inside one part (a hash check, a guard) is not a message: put it in
+  \`say\` or in a \`show\` row of that part.
 - Keep an SVG to one or two steps. The SVG plays every step in a loop, with no controls.
 - Use the React player, \`<Flow {...props} />\` from \`flowfig\`, for a page that needs tabs, pause or hover.
 
@@ -240,6 +252,8 @@ npx flowfig - out.svg < spec.json      # render a spec from stdin
 npx flowfig spec.json out.svg          # render a spec file
 npx flowfig figure.ts out.svg          # render a module whose default export is a spec
 npx flowfig check <input> [--json]     # list the faults. The input can also be an SVG that flowfig wrote.
+npx flowfig verify <input>...          # check that the code each source names still exists
+npx flowfig diff <old> <new>           # list what changed in the spec between two figures
 npx flowfig --spec out.svg             # print the spec that an SVG carries
 npx flowfig docs                       # print this guide
 npx flowfig init                       # write these instructions for the coding agents of a repo
@@ -266,15 +280,16 @@ flowfig does not draw class or ER diagrams, Gantt charts or charts of numbers. F
 3. Write a fact list from the code and from its wiring (config, compose, route and queue files). Write each call as
    \`caller → callee: payload (file:line of the call)\`, in order. Include each async call and every consumer of a queue, each
    branch and error path, and each end state. Leave out what the code does not show.
-4. Write the spec from the fact list, with the real names and data. Render it with \`npx flowfig - out.svg\`. Fix every fault by
-   changing the layout first (rows, \`around\`, the gap). Never remove a fact to pass the check; if you must remove one, name it
-   in the reply. If \`small-text\` appears, split the figure; do not change \`--width\`.
+4. Write the spec from the fact list, with the real names and data. Render it with \`npx flowfig - out.svg <<'SPEC'\` and the
+   JSON in the heredoc. Fix every fault by changing the layout first (rows, \`around\`, the gap). Never remove a fact to pass
+   the check; if you must remove one, name it in the reply. If \`small-text\` appears, use two rows or split the figure; keep
+   the real names; do not change \`--width\`. Give each box and edge that draws code a \`source\` (\`file#symbol\`) from the fact list.
 5. Run \`npx flowfig --spec out.svg\` and compare it with the fact list: each edge must go from the caller to the callee that the
-   fact names. Fix each gap.
+   fact names. Fix each gap. Then run \`npx flowfig verify out.svg\` from the repo root and fix each fault.
 6. If you can open a browser, look at the SVG at two moments of the loop. If you cannot, write "not looked at" in the reply.
    Never report a look that you did not do.
 7. Reply with: the SVG path; what it shows, with the counts copied from the \`figure:\` line and the names copied from the read-back spec; what it leaves out and why;
-   the check line exactly as the command printed it.
+   the two lines the render printed, \`0 errors, 0 warnings\` and \`figure: ...\`, copied as printed.
 `;
 /** The description of the Claude skill: the words that make the agent load it. */
 export const SKILL_DESCRIPTION = 'Use when the user asks for a diagram, figure or animation of how code or a system works: an architecture, a data flow, a pipeline, a request lifecycle, a call sequence, a state lifecycle or a flowchart; when the user pastes a Mermaid flowchart, stateDiagram or sequenceDiagram to convert; or when the user asks for a class, ER or Gantt diagram.';

package/dist/index.js

@@ -203,6 +203,7 @@ export function Flow({ layout, edges, steps = [], theme, speed = 900, autoplay =
                     return [
                         {
                             id: `rail:${row.n}`,
+                            step: row.step,
                             from: rail.columns[row.from].id,
                             to: rail.columns[row.to].id,
                             curve: [c, c, c, c],

package/dist/init.d.ts

@@ -10,6 +10,19 @@ type Agent = {
     /** Text before the marked block in a whole file. */
     head?: string;
     note?: string;
+    /** The MCP config file the agent reads, and the top-level key that holds the servers. `type` adds `"type": "stdio"`. */
+    mcp?: {
+        file: string;
+        key: 'mcpServers' | 'servers';
+        type?: true;
+        global?: string;
+    };
+    /** Shown in place of the MCP file when init cannot write the config. */
+    mcpNote?: string;
+};
+export declare const MCP_ENTRY: {
+    command: string;
+    args: string[];
 };
 export declare const AGENTS: Agent[];
 /** The ids of the agents that the repo at `dir` already uses. */
@@ -20,6 +33,8 @@ export declare function toggle(input: string, selected: Set<string>, count: numb
 export declare function renderList(selected: Set<string>, detected: string[], dir: string): string;
 /** The new file text, or `undefined` if the file belongs to the user and init must leave it. `old` is `undefined` for a missing file. */
 export declare function place(a: Agent, old: string | undefined): string | undefined;
+/** The MCP file with the flowfig entry merged in, or `undefined` when the file is not a JSON object that can hold it. */
+export declare function registerMcp(a: Agent, old: string | undefined): string | undefined;
 /** Run `flowfig init`. Returns the exit code. */
 export declare function runInit(argv: string[]): Promise<number>;
 export {};

package/dist/init.js

@@ -1,11 +1,12 @@
 // `flowfig init`: write flowfig instructions for the coding agents of a repo. Pure functions where possible, so the tests need no TTY.
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { createInterface } from 'node:readline';
 import { AGENT_TEXT, SKILL_DESCRIPTION } from './guide.js';
 const START = '<!-- flowfig:start -->';
 const END = '<!-- flowfig:end -->';
+export const MCP_ENTRY = { command: 'npx', args: ['flowfig', 'mcp'] };
 export const AGENTS = [
     {
         id: 'claude',
@@ -13,6 +14,7 @@ export const AGENTS = [
         marks: ['.claude/', 'CLAUDE.md'],
         file: '.claude/skills/figure/SKILL.md',
         kind: 'whole',
+        mcp: { file: '.mcp.json', key: 'mcpServers', type: true, global: '.claude.json' },
         head: `---\nname: figure\ndescription: ${JSON.stringify(SKILL_DESCRIPTION)}\nuser_invocable: true\n---\n\n`,
     },
     { id: 'agents', name: 'AGENTS.md', marks: ['AGENTS.md'], file: 'AGENTS.md', kind: 'section', note: 'Codex, Amp, Jules, ...' },
@@ -22,6 +24,7 @@ export const AGENTS = [
         marks: ['.cursor/', '.cursorrules'],
         file: '.cursor/rules/flowfig.mdc',
         kind: 'whole',
+        mcp: { file: '.cursor/mcp.json', key: 'mcpServers', type: true, global: '.cursor/mcp.json' },
         head: '---\ndescription: Draw diagrams and flow figures with flowfig\nalwaysApply: false\n---\n\n',
     },
     {
@@ -30,10 +33,32 @@ export const AGENTS = [
         marks: ['.github/copilot-instructions.md'],
         file: '.github/copilot-instructions.md',
         kind: 'section',
+        mcp: { file: '.vscode/mcp.json', key: 'servers', type: true },
+    },
+    {
+        id: 'gemini',
+        name: 'Gemini CLI',
+        marks: ['GEMINI.md', '.gemini/'],
+        file: 'GEMINI.md',
+        kind: 'section',
+        mcp: { file: '.gemini/settings.json', key: 'mcpServers', global: '.gemini/settings.json' },
+    },
+    {
+        id: 'windsurf',
+        name: 'Windsurf',
+        marks: ['.windsurf/', '.windsurfrules'],
+        file: '.windsurf/rules/flowfig.md',
+        kind: 'whole',
+        mcpNote: 'add {"command":"npx","args":["flowfig","mcp"]} to the MCP config by hand',
+    },
+    {
+        id: 'kiro',
+        name: 'Kiro',
+        marks: ['.kiro/'],
+        file: '.kiro/steering/flowfig.md',
+        kind: 'whole',
+        mcp: { file: '.kiro/settings/mcp.json', key: 'mcpServers', global: '.kiro/settings/mcp.json' },
     },
-    { id: 'gemini', name: 'Gemini CLI', marks: ['GEMINI.md', '.gemini/'], file: 'GEMINI.md', kind: 'section' },
-    { id: 'windsurf', name: 'Windsurf', marks: ['.windsurf/', '.windsurfrules'], file: '.windsurf/rules/flowfig.md', kind: 'whole' },
-    { id: 'kiro', name: 'Kiro', marks: ['.kiro/'], file: '.kiro/steering/flowfig.md', kind: 'whole' },
 ];
 /** The ids of the agents that the repo at `dir` already uses. */
 export const detect = (dir) => AGENTS.filter((a) => a.marks.some((m) => existsSync(join(dir, m)))).map((a) => a.id);
@@ -77,12 +102,34 @@ export function place(a, old) {
         return old.slice(0, s) + mine.trimEnd() + old.slice(e + END.length);
     return old + (old.endsWith('\n\n') ? '' : old.endsWith('\n') ? '\n' : '\n\n') + mine;
 }
+/** The MCP file with the flowfig entry merged in, or `undefined` when the file is not a JSON object that can hold it. */
+export function registerMcp(a, old) {
+    if (!a.mcp)
+        return undefined;
+    let json;
+    try {
+        json = old === undefined ? {} : JSON.parse(old);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof json !== 'object' || json === null || Array.isArray(json))
+        return undefined;
+    const servers = json[a.mcp.key] ?? {};
+    if (typeof servers !== 'object' || servers === null || Array.isArray(servers))
+        return undefined;
+    if ('flowfig' in servers)
+        return old; // the user may have pinned a version or set env: keep the entry
+    const entry = a.mcp.type ? { ...MCP_ENTRY, type: 'stdio' } : MCP_ENTRY;
+    json[a.mcp.key] = { ...servers, flowfig: entry };
+    return JSON.stringify(json, null, 2) + '\n';
+}
 const HINT = 'run with -y or --agents <ids>';
 /** Run `flowfig init`. Returns the exit code. */
 export async function runInit(argv) {
     const args = [...argv];
     const flag = (n, ...alias) => [n, ...alias].some((x) => args.includes(x) && args.splice(args.indexOf(x), 1).length > 0);
-    const listAgents = flag('--list-agents'), all = flag('--all-agents'), yes = flag('-y', '--yes'), global = flag('--global'), dry = flag('--dry-run');
+    const listAgents = flag('--list-agents'), all = flag('--all-agents'), yes = flag('-y', '--yes'), global = flag('--global'), dry = flag('--dry-run'), noMcp = flag('--no-mcp');
     let ids;
     const at = args.indexOf('--agents');
     if (at !== -1)
@@ -100,7 +147,7 @@ export async function runInit(argv) {
     if (unknown)
         return fail(`init: unknown agent "${unknown}" (ids: ${AGENTS.map((a) => a.id).join(', ')})`);
     if (global && ids?.some((i) => i !== 'claude'))
-        return fail('init: --global writes only the claude skill (use --agents claude)');
+        return fail('init: --global writes only the Claude skill and the MCP entry (use --agents claude)');
     const detected = detect(dir);
     const auto = new Set(detected.length ? detected : ['agents']);
     let chosen;
@@ -142,6 +189,45 @@ export async function runInit(argv) {
             }
         }
         console.log(`${status.padEnd(9)} ${path}`);
+        if (noMcp)
+            continue;
+        if (a.mcpNote) {
+            console.log(`note      ${a.id}: ${a.mcpNote}`);
+            continue;
+        }
+        if (!a.mcp || (global && !a.mcp.global))
+            continue;
+        const mcpPath = global ? join(homedir(), a.mcp.global) : join(dir, a.mcp.file);
+        const oldMcp = existsSync(mcpPath) ? readFileSync(mcpPath, 'utf8') : undefined;
+        const nextMcp = registerMcp(a, oldMcp);
+        let mcpStatus;
+        if (nextMcp === undefined)
+            mcpStatus = `skipped (not a JSON object with ${a.mcp.key})`;
+        else if (nextMcp === oldMcp)
+            mcpStatus = 'unchanged';
+        else {
+            mcpStatus = oldMcp === undefined ? 'created' : 'updated';
+            if (dry)
+                mcpStatus = `would ${mcpStatus === 'created' ? 'create' : 'update'}`;
+            else {
+                mkdirSync(dirname(mcpPath), { recursive: true });
+                // Same-folder temp file, then rename: a crash or a parallel write cannot leave half a file (~/.claude.json holds user settings).
+                // Resolve a symlink first, so the rename replaces the target and not the link. Copy the old mode to the new file.
+                const real = existsSync(mcpPath) ? realpathSync(mcpPath) : mcpPath;
+                const tmp = `${real}.${process.pid}.tmp`;
+                try {
+                    writeFileSync(tmp, nextMcp);
+                    if (existsSync(real))
+                        chmodSync(tmp, statSync(real).mode & 0o777);
+                    renameSync(tmp, real);
+                }
+                catch (e) {
+                    rmSync(tmp, { force: true });
+                    throw e;
+                }
+            }
+        }
+        console.log(`${mcpStatus.padEnd(9)} ${mcpPath}`);
     }
     return 0;
 }

package/dist/load.d.ts

@@ -0,0 +1,12 @@
+import { type FlowProps } from './model.ts';
+import { type Finding, type SvgOptions } from './svg.ts';
+/** The spec JSON inside an SVG this package wrote. */
+export declare function specOf(svg: string, name: string): string;
+/** A spec from a `.json` or SVG path, or an object (`{ props }` or the props). Every error message starts with the name. */
+export declare function loadSpec(input: string | object, name?: string): FlowProps;
+/** The SVG with its spec in `<metadata>`: an SVG is then its own source. `]]>` would close the CDATA early, so it is escaped. */
+export declare function svgWithSpec(props: FlowProps, opts?: SvgOptions): string;
+/** Errors first, then by rule name. `strict` makes every warning an error. */
+export declare function sortFindings(findings: Finding[], strict: boolean): Finding[];
+/** One line per finding, the counts line (unless `withCounts` is false), and the `figure:` line. No color: the CLI adds it. */
+export declare function reportLines(props: FlowProps, findings: Finding[], withCounts?: boolean): string[];

package/dist/load.js

@@ -0,0 +1,59 @@
+// What the CLI and the MCP server share: read a spec, write an SVG that carries its spec, and print the check lines.
+import { readFileSync } from 'node:fs';
+import { counts } from './model.js';
+import { toSvg } from './svg.js';
+const SPEC_OPEN = '<metadata id="figure-spec"><![CDATA[';
+const SPEC_CLOSE = ']]></metadata>';
+/** The spec JSON inside an SVG this package wrote. */
+export function specOf(svg, name) {
+    const at = svg.indexOf(SPEC_OPEN);
+    if (at === -1)
+        throw new Error(`${name}: no figure spec inside this SVG`);
+    return svg.slice(at + SPEC_OPEN.length, svg.indexOf(SPEC_CLOSE, at));
+}
+/** A spec from a `.json` or SVG path, or an object (`{ props }` or the props). Every error message starts with the name. */
+export function loadSpec(input, name = typeof input === 'string' ? input : 'spec') {
+    let loaded = input;
+    if (typeof input === 'string') {
+        if (!input.endsWith('.json') && !input.endsWith('.svg'))
+            throw new Error(`${input}: expected a .json or .svg path`);
+        try {
+            const text = readFileSync(input, 'utf8');
+            loaded = JSON.parse(input.endsWith('.svg') ? specOf(text, input) : text);
+        }
+        catch (e) {
+            const m = e.message;
+            throw new Error(m.startsWith(`${input}: `) ? m : `${input}: ${m}`);
+        }
+    }
+    const props = (loaded?.props ?? loaded);
+    if (!props?.layout)
+        throw new Error(`${name}: no figure props (expected { props: { layout, edges, steps } })`);
+    if (!Array.isArray(props.edges))
+        throw new Error(`${name}: edges must be an array (use [] for none)`);
+    if (props.steps?.some((s) => !Array.isArray(s?.flow)))
+        throw new Error(`${name}: each step needs a flow array`);
+    return props;
+}
+/** The SVG with its spec in `<metadata>`: an SVG is then its own source. `]]>` would close the CDATA early, so it is escaped. */
+export function svgWithSpec(props, opts = {}) {
+    const spec = JSON.stringify({ props }).replaceAll(']]>', ']]\\u003e');
+    return toSvg(props, opts).replace(/(<svg[^>]*>\n?)/, (tag) => `${tag}${SPEC_OPEN}${spec}${SPEC_CLOSE}\n`);
+}
+/** Errors first, then by rule name. `strict` makes every warning an error. */
+export function sortFindings(findings, strict) {
+    return findings
+        .map((f) => (strict ? { ...f, severity: 'error' } : f))
+        .sort((a, b) => (a.severity === b.severity ? a.rule.localeCompare(b.rule) : a.severity === 'error' ? -1 : 1));
+}
+const n = (k, word) => `${k} ${word}${k === 1 ? '' : 's'}`;
+/** One line per finding, the counts line (unless `withCounts` is false), and the `figure:` line. No color: the CLI adds it. */
+export function reportLines(props, findings, withCounts = true) {
+    const out = findings.map((f) => `${f.severity.padEnd(8)} ${f.rule.padEnd(18)} ${f.message}`);
+    const errors = findings.filter((f) => f.severity === 'error').length;
+    if (withCounts)
+        out.push(`${n(errors, 'error')}, ${n(findings.length - errors, 'warning')}`);
+    const c = counts(props);
+    out.push(`figure: ${n(c.boxes, 'box').replace('boxs', 'boxes')}, ${n(c.groups, 'group')}, ${n(c.edges, 'edge')}, ${n(c.steps, 'step')}, ${n(c.messages, 'message')}`);
+    return out;
+}

package/dist/mcp.d.ts

@@ -0,0 +1,139 @@
+export type Response = {
+    jsonrpc: '2.0';
+    id: unknown;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+};
+export declare const TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            paths?: undefined;
+            root?: undefined;
+            strict?: undefined;
+            old?: undefined;
+            new?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            spec: {
+                description: string;
+                anyOf: {
+                    type: string;
+                }[];
+            };
+            strict: {
+                type: string;
+                description: string;
+            };
+            width: {
+                type: string;
+                description: string;
+            };
+            minText: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            spec: {
+                description: string;
+                anyOf: {
+                    type: string;
+                }[];
+            };
+            strict: {
+                type: string;
+                description: string;
+            };
+            width: {
+                type: string;
+                description: string;
+            };
+            minText: {
+                type: string;
+                description: string;
+            };
+            out: {
+                type: string;
+                description: string;
+            };
+            paths?: undefined;
+            root?: undefined;
+            old?: undefined;
+            new?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            paths: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            root: {
+                type: string;
+                description: string;
+            };
+            strict: {
+                type: string;
+            };
+            old?: undefined;
+            new?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            paths?: undefined;
+            root?: undefined;
+            strict?: undefined;
+            old: {
+                description: string;
+                anyOf: {
+                    type: string;
+                }[];
+            };
+            new: {
+                description: string;
+                anyOf: {
+                    type: string;
+                }[];
+            };
+        };
+        required: string[];
+    };
+})[];
+/** One JSON-RPC message in, one response out; `undefined` for a notification. Pure, so the tests call it directly. */
+export declare function handle(message: unknown): Response | undefined;
+/** Read one message per line from `input`, write one response per line to `output`. Returns when `input` ends. */
+export declare function serve(input: NodeJS.ReadableStream, output: NodeJS.WritableStream): Promise<void>;