wasm-mcp 0.1.0

package/dist/parser/instructions.d.ts

@@ -0,0 +1,171 @@
+import { z } from "zod";
+export declare const INSTRUCTION_CATEGORIES: readonly ["control", "numeric", "parametric", "variable", "table", "memory", "ref", "i31", "struct", "array", "extern", "vec"];
+export type InstructionCategory = (typeof INSTRUCTION_CATEGORIES)[number];
+export declare const WASM_VERSIONS: readonly ["1.0", "2.0", "3.0"];
+export type WasmVersion = (typeof WASM_VERSIONS)[number];
+/** A single instruction record exposed by the MCP tools. */
+export interface InstructionRecord {
+    /** Lowercase wasm syntax mnemonic, e.g. `"i32.add"`, `"br_if"`. */
+    mnemonic: string;
+    /**
+     * Binary opcode encoding as a byte sequence. Single-byte for
+     * classic opcodes (`[0x6A]` for `i32.add`); multi-byte for
+     * prefix-encoded families (`[0xFD, 0x89, 0x02]` for vector
+     * `i8x16.relaxed_laneselect`).
+     */
+    opcodes: number[];
+    /** Spec category this instruction belongs to. */
+    category: InstructionCategory;
+    /**
+     * Minimum spec version that introduced this instruction.
+     * `"1.0"` (MVP), `"2.0"` (Wasm 2), `"3.0"` (Wasm 3 — exception
+     * handling, GC, threads, tail calls, relaxed SIMD).
+     */
+    version: WasmVersion;
+    /**
+     * Stack type signature. `params_raw` / `results_raw` are the raw
+     * LaTeX strings as upstream wrote them (e.g. `"[t_1^\\ast~\\I32]"`);
+     * the runtime keeps them verbatim because the full stack-type
+     * grammar (polymorphic, type variables, vector splats) is richer
+     * than a flat list. A future release may add a fully decoded
+     * `params` / `results` alongside.
+     */
+    signature: {
+        params_raw: string;
+        results_raw: string;
+    };
+    /**
+     * Fragment identifiers within the rendered spec — e.g.
+     * `valid-br_if`, `exec-br_if`. Stable across spec releases.
+     */
+    anchors: {
+        validation: string;
+        execution: string;
+    };
+    /**
+     * Full URLs into the rendered spec at
+     * `https://webassembly.github.io/spec/core/`. Built from `anchors`
+     * by `instructionUrl`.
+     */
+    urls: {
+        validation: string;
+        execution: string;
+    };
+}
+export declare const InstructionRecordSchema: z.ZodObject<{
+    mnemonic: z.ZodString;
+    opcodes: z.ZodArray<z.ZodNumber>;
+    category: z.ZodEnum<{
+        control: "control";
+        numeric: "numeric";
+        parametric: "parametric";
+        variable: "variable";
+        table: "table";
+        memory: "memory";
+        ref: "ref";
+        i31: "i31";
+        struct: "struct";
+        array: "array";
+        extern: "extern";
+        vec: "vec";
+    }>;
+    version: z.ZodEnum<{
+        "1.0": "1.0";
+        "2.0": "2.0";
+        "3.0": "3.0";
+    }>;
+    signature: z.ZodObject<{
+        params_raw: z.ZodString;
+        results_raw: z.ZodString;
+    }, z.core.$strip>;
+    anchors: z.ZodObject<{
+        validation: z.ZodString;
+        execution: z.ZodString;
+    }, z.core.$strip>;
+    urls: z.ZodObject<{
+        validation: z.ZodURL;
+        execution: z.ZodURL;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export interface RawInstruction {
+    version: number | null;
+    name: string | null;
+    opcode: string | null;
+    type: string | null;
+    validation: string | null;
+    execution: string | null;
+    operator: string | null;
+    validation2: string | null;
+    execution2: string | null;
+}
+export interface RawMacro {
+    body: string;
+    kind: "instruction" | "type" | "other";
+    category: string | null;
+    section: string;
+    anchor: string;
+}
+export interface RawDump {
+    instructions: RawInstruction[];
+    macros: Record<string, RawMacro>;
+}
+/** Build a full anchor URL into the rendered spec. */
+export declare function instructionUrl(anchor: string): string;
+/** Parse `\hex{0C}` or `\hex{FD}~~\hex{89}~~\hex{02}` into a byte array. */
+export declare function parseOpcode(latex: string): number[];
+/**
+ * Resolve a LaTeX name like `\I32.\ADD` or `\BR~l` into the wasm
+ * syntax mnemonic. The leading `\` macros are expanded via the
+ * macro table; everything from the first `~` onwards is dropped
+ * (immediate operands aren't part of the mnemonic).
+ */
+export declare function resolveMnemonic(nameLatex: string, macros: Record<string, RawMacro>): string | null;
+/** Split a `type` LaTeX string like `[a] \to [b]` into params/results. */
+export declare function parseSignature(typeLatex: string): {
+    params_raw: string;
+    results_raw: string;
+};
+/**
+ * Resolve the category of an instruction by finding its primary
+ * macro in the name and looking up its instruction-category tag.
+ * For `\I32.\ADD` the primary macro is `\ADD` (an instruction macro);
+ * `\I32` is a type macro and contributes no category.
+ */
+export declare function resolveCategory(nameLatex: string, macros: Record<string, RawMacro>): InstructionCategory | null;
+export interface NormalizeReport {
+    records: InstructionRecord[];
+    skipped: {
+        /** Opcode slots upstream marks as reserved (version 0.0, name null). */
+        reserved: number;
+        /**
+         * Structural delimiters like `else` and `end` — listed in the
+         * appendix for opcode-coverage reasons but with no validation or
+         * execution prose, since they're not standalone instructions.
+         */
+        structural: {
+            name: string;
+            opcode: string | null;
+        }[];
+        missing_macro: {
+            name: string;
+            opcode: string | null;
+        }[];
+        missing_category: {
+            name: string;
+            opcode: string | null;
+        }[];
+        incomplete: {
+            name: string | null;
+            opcode: string | null;
+            reason: string;
+        }[];
+    };
+}
+/**
+ * Normalise a raw dump into clean instruction records. Reserved /
+ * inactive opcodes (version 0.0 with `name: null`) are skipped and
+ * reported. Any instruction whose macro / category can't be
+ * resolved is also skipped and reported so the build can surface
+ * upstream changes the parser doesn't yet handle.
+ */
+export declare function normalizeInstructions(dump: RawDump): NormalizeReport;

package/dist/parser/instructions.js

@@ -0,0 +1,241 @@
+// Normalise the raw instruction + macro JSON dumped by
+// `src/parser/upstream.ts` into clean, agent-friendly
+// `InstructionRecord`s.
+//
+// The upstream `index-instructions.py` uses LaTeX macros for
+// readability ("\I32.\ADD", "\hex{0C}", "[t_1^\ast~\I32] \to [t_2^\ast]").
+// The macro table in `util/macros.def` defines the mathdef → mnemonic
+// mapping ("\BRIF" → `br_if`, with category `control`). This module
+// joins the two and emits a stable record shape that the runtime
+// tools query directly — no LaTeX in the surface area.
+import { z } from "zod";
+export const INSTRUCTION_CATEGORIES = [
+    "control",
+    "numeric",
+    "parametric",
+    "variable",
+    "table",
+    "memory",
+    "ref",
+    "i31",
+    "struct",
+    "array",
+    "extern",
+    "vec",
+];
+export const WASM_VERSIONS = ["1.0", "2.0", "3.0"];
+export const InstructionRecordSchema = z.object({
+    mnemonic: z.string(),
+    opcodes: z.array(z.number().int().min(0).max(0xff)),
+    category: z.enum(INSTRUCTION_CATEGORIES),
+    version: z.enum(WASM_VERSIONS),
+    signature: z.object({ params_raw: z.string(), results_raw: z.string() }),
+    anchors: z.object({ validation: z.string(), execution: z.string() }),
+    urls: z.object({ validation: z.url(), execution: z.url() }),
+});
+const SPEC_BASE = "https://webassembly.github.io/spec/core";
+/** Build a full anchor URL into the rendered spec. */
+export function instructionUrl(anchor) {
+    if (anchor.startsWith("valid-"))
+        return `${SPEC_BASE}/valid/instructions.html#${anchor}`;
+    if (anchor.startsWith("exec-"))
+        return `${SPEC_BASE}/exec/instructions.html#${anchor}`;
+    return `${SPEC_BASE}/#${anchor}`;
+}
+/** Parse `\hex{0C}` or `\hex{FD}~~\hex{89}~~\hex{02}` into a byte array. */
+export function parseOpcode(latex) {
+    const bytes = [];
+    const re = /\\hex\{([0-9A-Fa-f]+)\}/g;
+    for (const m of latex.matchAll(re)) {
+        bytes.push(parseInt(m[1], 16));
+    }
+    return bytes;
+}
+/**
+ * Render one dot-separated segment of a LaTeX instruction name.
+ *
+ * A segment is a sequence of LaTeX tokens that together form one
+ * piece of the mnemonic between dots — e.g. `\I32`, `\BRIF`, or the
+ * compound `\LOAD\K{8\_s}` (which becomes `load8_s`). Tokens we
+ * recognise:
+ *
+ *   `\MACRO`        Look up in the macro table; emit its `body`.
+ *   `\K{...}`       Literal text (operator suffix). Emit with LaTeX
+ *                   escapes stripped — `\_` → `_`, `{.}` → `.`.
+ *
+ * Unknown token shapes cause the segment to fail (returns null) so
+ * the caller can report the upstream addition rather than silently
+ * misnaming the instruction.
+ */
+function renderSegment(seg, macros) {
+    let i = 0;
+    const out = [];
+    while (i < seg.length) {
+        if (seg[i] === " " || seg[i] === "\t") {
+            i += 1;
+            continue;
+        }
+        if (seg[i] !== "\\")
+            return null;
+        // `\K{...}` literal text run — read the body with one level of
+        // nested-brace tolerance.
+        if (seg.startsWith("\\K{", i)) {
+            i += 3;
+            let depth = 1;
+            const start = i;
+            while (i < seg.length && depth > 0) {
+                if (seg[i] === "{")
+                    depth += 1;
+                else if (seg[i] === "}")
+                    depth -= 1;
+                if (depth > 0)
+                    i += 1;
+            }
+            if (depth !== 0)
+                return null;
+            const body = seg.slice(start, i);
+            i += 1;
+            out.push(body.replace(/\\_/g, "_").replace(/\{\.\}/g, "."));
+            continue;
+        }
+        // `\MACRO` — capture identifier of letters/digits.
+        const macroMatch = seg.slice(i).match(/^\\([A-Za-z0-9]+)/);
+        if (!macroMatch)
+            return null;
+        const macro = macros[macroMatch[1]];
+        if (!macro)
+            return null;
+        out.push(macro.body);
+        i += macroMatch[0].length;
+    }
+    if (out.length === 0)
+        return null;
+    return out.join("");
+}
+/**
+ * Resolve a LaTeX name like `\I32.\ADD` or `\BR~l` into the wasm
+ * syntax mnemonic. The leading `\` macros are expanded via the
+ * macro table; everything from the first `~` onwards is dropped
+ * (immediate operands aren't part of the mnemonic).
+ */
+export function resolveMnemonic(nameLatex, macros) {
+    // Drop immediates: `\BR~l` → `\BR`, `\IF~\X{bt}` → `\IF`.
+    const headOnly = nameLatex.split("~")[0].trim();
+    const rendered = [];
+    for (const seg of headOnly.split(".")) {
+        const trimmed = seg.trim();
+        if (trimmed === "")
+            continue;
+        const piece = renderSegment(trimmed, macros);
+        if (piece === null)
+            return null;
+        rendered.push(piece);
+    }
+    if (rendered.length === 0)
+        return null;
+    return rendered.join(".");
+}
+/** Split a `type` LaTeX string like `[a] \to [b]` into params/results. */
+export function parseSignature(typeLatex) {
+    const parts = typeLatex.split(/\\to/);
+    const lhs = (parts[0] ?? "").trim();
+    const rhs = (parts[1] ?? "").trim();
+    return { params_raw: lhs, results_raw: rhs };
+}
+/**
+ * Resolve the category of an instruction by finding its primary
+ * macro in the name and looking up its instruction-category tag.
+ * For `\I32.\ADD` the primary macro is `\ADD` (an instruction macro);
+ * `\I32` is a type macro and contributes no category.
+ */
+export function resolveCategory(nameLatex, macros) {
+    const headOnly = nameLatex.split("~")[0].trim();
+    // Walk every `\MACRO` token in the head (across all dot-segments)
+    // and return the first one whose macro is an instruction macro.
+    // Type macros (`\I32`) carry no category — they're skipped — so
+    // `\I32.\ADD` resolves via `\ADD` to `numeric`.
+    for (const m of headOnly.matchAll(/\\([A-Za-z0-9]+)/g)) {
+        const macro = macros[m[1]];
+        if (macro?.kind === "instruction" && macro.category) {
+            const cat = macro.category;
+            if (INSTRUCTION_CATEGORIES.includes(cat))
+                return cat;
+        }
+    }
+    return null;
+}
+function isWasmVersion(v) {
+    return v === 1.0 || v === 2.0 || v === 3.0;
+}
+/**
+ * Normalise a raw dump into clean instruction records. Reserved /
+ * inactive opcodes (version 0.0 with `name: null`) are skipped and
+ * reported. Any instruction whose macro / category can't be
+ * resolved is also skipped and reported so the build can surface
+ * upstream changes the parser doesn't yet handle.
+ */
+export function normalizeInstructions(dump) {
+    const records = [];
+    const report = {
+        reserved: 0,
+        structural: [],
+        missing_macro: [],
+        missing_category: [],
+        incomplete: [],
+    };
+    for (const raw of dump.instructions) {
+        if (raw.name === null || raw.version === 0.0) {
+            report.reserved += 1;
+            continue;
+        }
+        // Structural markers (`else`, `end`) have a name + version but
+        // no validation / execution prose because they aren't
+        // standalone instructions — they delimit blocks. Bucket them
+        // separately so the count is informational, not a parser
+        // failure.
+        if (raw.type === null && raw.validation === null && raw.execution === null) {
+            report.structural.push({ name: raw.name, opcode: raw.opcode });
+            continue;
+        }
+        if (!isWasmVersion(raw.version) || !raw.opcode || !raw.type || !raw.validation || !raw.execution) {
+            report.incomplete.push({
+                name: raw.name,
+                opcode: raw.opcode,
+                reason: "missing required field (opcode/type/validation/execution/version)",
+            });
+            continue;
+        }
+        const mnemonic = resolveMnemonic(raw.name, dump.macros);
+        if (mnemonic === null) {
+            report.missing_macro.push({ name: raw.name, opcode: raw.opcode });
+            continue;
+        }
+        const category = resolveCategory(raw.name, dump.macros);
+        if (category === null) {
+            report.missing_category.push({ name: raw.name, opcode: raw.opcode });
+            continue;
+        }
+        const opcodes = parseOpcode(raw.opcode);
+        if (opcodes.length === 0) {
+            report.incomplete.push({ name: raw.name, opcode: raw.opcode, reason: "no \\hex bytes parsed" });
+            continue;
+        }
+        // raw.version comes in as a JS number (1.0 / 2.0 / 3.0).
+        // String(1.0) drops the trailing `.0`, so use toFixed(1) to get
+        // the canonical `"1.0"`/`"2.0"`/`"3.0"` form.
+        const version = raw.version.toFixed(1);
+        records.push({
+            mnemonic,
+            opcodes,
+            category,
+            version,
+            signature: parseSignature(raw.type),
+            anchors: { validation: raw.validation, execution: raw.execution },
+            urls: {
+                validation: instructionUrl(raw.validation),
+                execution: instructionUrl(raw.execution),
+            },
+        });
+    }
+    return { records, skipped: report };
+}

package/dist/parser/proposals.d.ts

@@ -0,0 +1,30 @@
+export declare const PROPOSAL_STATUSES: readonly ["phase-0", "phase-1", "phase-2", "phase-3", "phase-4", "phase-5", "finished", "inactive"];
+export type ProposalStatus = (typeof PROPOSAL_STATUSES)[number];
+export interface Proposal {
+    /** Proposal display name, e.g. `Threads`, `Garbage collection`. */
+    name: string;
+    /** Lifecycle status / phase. */
+    status: ProposalStatus;
+    /** Numeric phase 0–5 for active/finished proposals; null otherwise. */
+    phase: number | null;
+    /** Champion(s) as written, e.g. `Andreas Rossberg`. */
+    champion: string;
+    /** Resolved proposal URL (repo / design doc), or null if unlinked. */
+    url: string | null;
+    /** For finished proposals: affected specs, e.g. `["core", "js-api"]`. */
+    affected_specs: string[];
+    /** For finished proposals: spec version it landed in, e.g. `3.0`. */
+    spec_version: string | null;
+}
+/** Parse README.md (active proposals across phase headings). */
+export declare function parseActiveProposals(markdown: string): Proposal[];
+/** Parse finished-proposals.md (extra affected-specs + version columns). */
+export declare function parseFinishedProposals(markdown: string): Proposal[];
+/** Parse inactive-proposals.md. */
+export declare function parseInactiveProposals(markdown: string): Proposal[];
+/** Parse all three files into one deduplicated, sorted list. */
+export declare function parseAllProposals(files: {
+    readme: string;
+    finished: string;
+    inactive: string;
+}): Proposal[];

package/dist/parser/proposals.js

@@ -0,0 +1,188 @@
+// Parse the WebAssembly/proposals repository's Markdown tables into a
+// structured proposal index.
+//
+// Proposals live in three Markdown files:
+//   README.md              — active proposals, grouped under
+//                            `### Phase N - ...` headings (phases 0–5).
+//   finished-proposals.md  — finished (merged) proposals, with extra
+//                            columns for affected specs + spec version.
+//   inactive-proposals.md  — inactive proposals.
+//
+// Each table row names a proposal via a reference-style link
+// (`[Name][ref]` or `[Name](url)`); the `[ref]: url` definitions sit
+// at the bottom of each file. We resolve those to absolute URLs.
+export const PROPOSAL_STATUSES = [
+    "phase-0",
+    "phase-1",
+    "phase-2",
+    "phase-3",
+    "phase-4",
+    "phase-5",
+    "finished",
+    "inactive",
+];
+/** Collect `[ref]: url` reference-link definitions (case-insensitive keys). */
+function collectLinkDefs(markdown) {
+    const defs = new Map();
+    for (const line of markdown.split("\n")) {
+        const m = line.match(/^\[([^\]]+)\]:\s*(\S+)/);
+        if (m)
+            defs.set(m[1].toLowerCase(), m[2]);
+    }
+    return defs;
+}
+/** Split a Markdown table row into trimmed cell strings. */
+function splitRow(row) {
+    return row
+        .replace(/^\s*\|/, "")
+        .replace(/\|\s*$/, "")
+        .split("|")
+        .map((c) => c.trim());
+}
+function isTableRow(line) {
+    return /^\s*\|/.test(line) && line.includes("|");
+}
+function isSeparatorRow(line) {
+    return /^\s*\|?[\s:|-]+$/.test(line) && line.includes("-");
+}
+/**
+ * Resolve a proposal name cell (`[Name][ref]`, `[Name](url)`, or
+ * plain text) to { name, url }.
+ */
+function parseNameCell(cell, linkDefs) {
+    // [Name][ref]
+    let m = cell.match(/^\[([^\]]+)\]\[([^\]]*)\]/);
+    if (m) {
+        const name = m[1].trim();
+        const ref = (m[2].trim() || name).toLowerCase();
+        return { name, url: linkDefs.get(ref) ?? null };
+    }
+    // [Name](url)
+    m = cell.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+    if (m)
+        return { name: m[1].trim(), url: m[2].trim() };
+    // [Name] (shortcut reference)
+    m = cell.match(/^\[([^\]]+)\]/);
+    if (m) {
+        const name = m[1].trim();
+        return { name, url: linkDefs.get(name.toLowerCase()) ?? null };
+    }
+    return { name: cell.trim(), url: null };
+}
+const PHASE_HEADING = /^#{2,4}\s+Phase\s+(\d+)\b/i;
+/** Parse README.md (active proposals across phase headings). */
+export function parseActiveProposals(markdown) {
+    const linkDefs = collectLinkDefs(markdown);
+    const out = [];
+    let currentPhase = null;
+    const lines = markdown.split("\n");
+    for (const line of lines) {
+        const heading = line.match(PHASE_HEADING);
+        if (heading) {
+            currentPhase = parseInt(heading[1], 10);
+            continue;
+        }
+        if (currentPhase === null)
+            continue;
+        if (!isTableRow(line) || isSeparatorRow(line))
+            continue;
+        const cells = splitRow(line);
+        if (cells.length < 2)
+            continue;
+        // Skip header rows ("Proposal | Champion").
+        if (/^proposals?$/i.test(cells[0]))
+            continue;
+        const { name, url } = parseNameCell(cells[0], linkDefs);
+        if (!name)
+            continue;
+        out.push({
+            name,
+            status: `phase-${currentPhase}`,
+            phase: currentPhase,
+            champion: cells[1],
+            url,
+            affected_specs: [],
+            spec_version: null,
+        });
+    }
+    return out;
+}
+/** Parse finished-proposals.md (extra affected-specs + version columns). */
+export function parseFinishedProposals(markdown) {
+    const linkDefs = collectLinkDefs(markdown);
+    const out = [];
+    for (const line of markdown.split("\n")) {
+        if (!isTableRow(line) || isSeparatorRow(line))
+            continue;
+        const cells = splitRow(line);
+        if (cells.length < 2)
+            continue;
+        if (/^proposals?$/i.test(cells[0]))
+            continue;
+        const { name, url } = parseNameCell(cells[0], linkDefs);
+        if (!name)
+            continue;
+        // Columns: Proposal | Champion | Meeting notes | Affected specs | Spec Version
+        const affectedRaw = cells[3] ?? "";
+        const affected_specs = affectedRaw
+            .split(",")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0 && /^[a-z-]+$/.test(s));
+        const spec_version = (cells[4] ?? "").trim() || null;
+        out.push({
+            name,
+            status: "finished",
+            phase: 4,
+            champion: cells[1],
+            url,
+            affected_specs,
+            spec_version,
+        });
+    }
+    return out;
+}
+/** Parse inactive-proposals.md. */
+export function parseInactiveProposals(markdown) {
+    const linkDefs = collectLinkDefs(markdown);
+    const out = [];
+    for (const line of markdown.split("\n")) {
+        if (!isTableRow(line) || isSeparatorRow(line))
+            continue;
+        const cells = splitRow(line);
+        if (cells.length < 2)
+            continue;
+        if (/^proposals?$/i.test(cells[0]))
+            continue;
+        const { name, url } = parseNameCell(cells[0], linkDefs);
+        if (!name)
+            continue;
+        out.push({
+            name,
+            status: "inactive",
+            phase: null,
+            champion: cells[1],
+            url,
+            affected_specs: [],
+            spec_version: null,
+        });
+    }
+    return out;
+}
+/** Parse all three files into one deduplicated, sorted list. */
+export function parseAllProposals(files) {
+    const all = [
+        ...parseActiveProposals(files.readme),
+        ...parseFinishedProposals(files.finished),
+        ...parseInactiveProposals(files.inactive),
+    ];
+    // Dedupe by name, preferring the more-advanced status (finished >
+    // higher phase > inactive). A proposal should only appear once.
+    const rank = (p) => p.status === "finished" ? 100 : p.phase !== null ? p.phase : -1;
+    const byName = new Map();
+    for (const p of all) {
+        const existing = byName.get(p.name);
+        if (!existing || rank(p) > rank(existing))
+            byName.set(p.name, p);
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/parser/sections.d.ts

@@ -0,0 +1,27 @@
+export interface SpecClause {
+    /** Primary id — first attached anchor, else a slug of the title. */
+    id: string;
+    /** Every `.. _label:` anchor that addresses this clause. */
+    anchors: string[];
+    /** Heading text, or null for an anchor-only content block. */
+    title: string | null;
+    /** Heading depth (1 = page title). 0 for anchor-only blocks. */
+    level: number;
+    /** Source file relative to `document/core/`, e.g. `syntax/types`. */
+    path: string;
+    /** Cleaned prose text (SpecTec splices + RST roles stripped). */
+    prose: string;
+    /** `:ref:` cross-reference targets cited in this clause. */
+    crossrefs: string[];
+    /** SpecTec rule / syntax names referenced by splice macros. */
+    formal_refs: string[];
+    /** Full URL into the rendered spec. */
+    url: string;
+}
+/** Map a source path + anchor to the rendered spec URL. */
+export declare function clauseUrl(path: string, anchor: string | null): string;
+/**
+ * Parse one RST document into clauses. `path` is the source-relative
+ * path without extension (e.g. `syntax/types`).
+ */
+export declare function parseRst(source: string, path: string): SpecClause[];