wasm-mcp 0.1.0

package/dist/parser/sections.js

@@ -0,0 +1,213 @@
+// Parse the WebAssembly core spec's reStructuredText sources into a
+// flat, anchor-addressable clause index.
+//
+// Since March 2025 the spec is authored in SpecTec: the `.rst` files
+// carry hand-written prose interleaved with SpecTec splice macros
+// (`$${syntax: numtype}`, `$${rule-prose: Step_pure/nop}`,
+// `${:I32}`). The OCaml SpecTec tool expands those into the formal
+// grammar / typing / reduction notation at build time. We do NOT run
+// SpecTec here — that keeps the build deterministic over the pinned
+// SHA without an OCaml toolchain. Instead we:
+//
+//   - keep the hand-written prose (rich for syntax/binary/text/intro/
+//     appendix sections),
+//   - record the SpecTec rule / syntax names the splices reference
+//     (`formal_refs`) so callers can see which formal rule a clause
+//     defines and follow the rendered URL for the notation itself,
+//   - resolve every `:ref:` cross-reference target.
+//
+// Each clause is addressable by any of the `.. _anchor:` labels that
+// attach to it, mirroring the stable fragment ids in the rendered
+// spec.
+const SPEC_BASE = "https://webassembly.github.io/spec/core";
+/** Map a source path + anchor to the rendered spec URL. */
+export function clauseUrl(path, anchor) {
+    const page = `${SPEC_BASE}/${path}.html`;
+    return anchor ? `${page}#${anchor}` : page;
+}
+function slugify(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/** Is `underline` a valid RST heading underline for `title`? */
+function isUnderline(underline, title) {
+    if (underline.length < 1)
+        return false;
+    const ch = underline[0];
+    if (!"=-~^\"`+*#:.'_".includes(ch))
+        return false;
+    if (![...underline].every((c) => c === ch))
+        return false;
+    // RST requires the underline to be at least as long as the title.
+    return underline.length >= title.trim().length && title.trim().length > 0;
+}
+/**
+ * Strip SpecTec splice macros and RST inline roles from a prose
+ * block, collecting cross-reference targets and formal-rule names as
+ * a side effect.
+ */
+function cleanProse(raw, crossrefs, formalRefs) {
+    let text = raw;
+    const collectRefs = (body) => {
+        // body like "rule-prose: Step_pure/nop", "syntax: numtype",
+        // "rule: {Step_pure/select-*}", or ":I32" (inline atom).
+        const colon = body.indexOf(":");
+        const payload = (colon >= 0 ? body.slice(colon + 1) : body).trim();
+        const names = [];
+        for (const ref of payload.split(/[\s,]+/)) {
+            const name = ref.replace(/[{}]/g, "").trim();
+            if (name && /[A-Za-z]/.test(name)) {
+                formalRefs.add(name);
+                names.push(name);
+            }
+        }
+        return names;
+    };
+    // Block-level SpecTec splices `$${...}` — whole formal blocks
+    // (grammar, typing/reduction rules). Record the referenced names
+    // and drop the block from prose. The brace body may nest one level
+    // (`$${rule: {Step_pure/nop}}`).
+    text = text.replace(/\$\$\{(?:[^{}]|\{[^{}]*\})*\}/g, (m) => {
+        collectRefs(m.slice(3, -1));
+        return "";
+    });
+    // Inline SpecTec atoms `${...}` — a single type / keyword / value
+    // reference rendered inline. Record the name and keep it readable
+    // (`${:I32}` → `I32`, `${:SELECT}` → `SELECT`).
+    text = text.replace(/\$\{(?:[^{}]|\{[^{}]*\})*\}/g, (m) => {
+        const names = collectRefs(m.slice(2, -1));
+        return names.join(" ");
+    });
+    // :ref:`text <target>` and :ref:`target` → keep text, record target.
+    text = text.replace(/:ref:`([^`<]+?)\s*<([^>]+)>`/g, (_m, label, target) => {
+        crossrefs.add(target.trim());
+        return label.trim();
+    });
+    text = text.replace(/:ref:`([^`]+)`/g, (_m, target) => {
+        crossrefs.add(target.trim());
+        return target.trim();
+    });
+    // Other RST roles: :math:`x`, :code:`x`, :token:`x`, :superscript:`x`
+    // → keep the inner content.
+    text = text.replace(/:[a-z]+:`([^`]*)`/g, "$1");
+    // Substitution refs: |IEEE754|_ or |foo| → strip the bars.
+    text = text.replace(/\|([A-Za-z0-9_]+)\|_?/g, "$1");
+    // Emphasis markers (keep the words).
+    text = text.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1");
+    text = text.replace(/``([^`]+)``/g, "$1");
+    // Collapse whitespace.
+    return text.replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+/**
+ * Parse one RST document into clauses. `path` is the source-relative
+ * path without extension (e.g. `syntax/types`).
+ */
+export function parseRst(source, path) {
+    const lines = source.split("\n");
+    // First pass: discover the order in which underline chars appear so
+    // we can assign heading levels the RST way (first char seen = level 1).
+    const charLevels = new Map();
+    for (let i = 0; i + 1 < lines.length; i++) {
+        const title = lines[i];
+        const underline = lines[i + 1];
+        if (title.trim() !== "" && isUnderline(underline.trim(), title)) {
+            const ch = underline.trim()[0];
+            if (!charLevels.has(ch))
+                charLevels.set(ch, charLevels.size + 1);
+        }
+    }
+    const blocks = [];
+    let pendingAnchors = [];
+    let current = null;
+    const flush = () => {
+        if (current)
+            blocks.push(current);
+        current = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Anchor label: `.. _name:`
+        const anchorMatch = trimmed.match(/^\.\.\s+_([A-Za-z0-9_.-]+):$/);
+        if (anchorMatch) {
+            pendingAnchors.push(anchorMatch[1]);
+            continue;
+        }
+        // Heading: a non-blank line followed by an underline.
+        const next = lines[i + 1];
+        if (trimmed !== "" && next !== undefined && isUnderline(next.trim(), line)) {
+            flush();
+            current = {
+                anchors: pendingAnchors,
+                title: trimmed,
+                level: charLevels.get(next.trim()[0]) ?? 1,
+                bodyLines: [],
+            };
+            pendingAnchors = [];
+            i++; // consume the underline line
+            continue;
+        }
+        // Other `.. directive::` lines (index, note, etc.). An anchor's
+        // content can be a bare splice/paragraph, so anchors that were
+        // pending and are now hitting non-heading content start an
+        // anchor-only block.
+        if (pendingAnchors.length > 0 && trimmed !== "") {
+            flush();
+            current = { anchors: pendingAnchors, title: null, level: 0, bodyLines: [] };
+            pendingAnchors = [];
+        }
+        if (current)
+            current.bodyLines.push(line);
+    }
+    flush();
+    // Drop pure `.. index::` / directive noise from body and build clauses.
+    const clauses = [];
+    for (const block of blocks) {
+        const crossrefs = new Set();
+        const formalRefs = new Set();
+        // Remove standalone directive blocks we don't surface as prose:
+        // `.. index::` (+ its indented continuation lines) and the
+        // `.. toctree::` / `.. only::` machinery. Keep `.. note::` /
+        // `.. warning::` bodies as prose.
+        const kept = [];
+        let skippingDirective = false;
+        for (const raw of block.bodyLines) {
+            const directive = raw.match(/^\.\.\s+([a-z-]+)::/);
+            if (directive) {
+                const name = directive[1];
+                skippingDirective = ["index", "toctree", "only", "math"].includes(name);
+                if (skippingDirective)
+                    continue;
+                // Admonitions: drop the directive marker, keep following text.
+                continue;
+            }
+            // Indented continuation of a skipped directive.
+            if (skippingDirective) {
+                if (raw.trim() === "" || /^\s/.test(raw))
+                    continue;
+                skippingDirective = false;
+            }
+            kept.push(raw);
+        }
+        const prose = cleanProse(kept.join("\n"), crossrefs, formalRefs);
+        const anchors = block.anchors;
+        const id = anchors[0] ?? (block.title ? `${path}-${slugify(block.title)}` : path);
+        // Skip empty connective blocks (no anchor, no title, no prose).
+        if (anchors.length === 0 && block.title === null && prose === "")
+            continue;
+        clauses.push({
+            id,
+            anchors,
+            title: block.title,
+            level: block.level,
+            path,
+            prose,
+            crossrefs: [...crossrefs],
+            formal_refs: [...formalRefs],
+            url: clauseUrl(path, anchors[0] ?? null),
+        });
+    }
+    return clauses;
+}

package/dist/parser/types.d.ts

@@ -0,0 +1,37 @@
+import type { SpecClause } from "./sections.js";
+export type TypeKind = "number" | "vector" | "reference" | "form";
+export interface TypeEntry {
+    /** Type or type-form name, e.g. `i32`, `funcref`, `functype`. */
+    name: string;
+    /** Classification of this entry. */
+    kind: TypeKind;
+    /** Defining clause anchor, e.g. `syntax-numtype`, `syntax-functype`. */
+    anchor: string;
+    /** For category types: the sibling concrete types (e.g. the four
+     *  number types). Empty for type forms. */
+    members: string[];
+    /** Defining clause title, e.g. `Number Types`. */
+    title: string | null;
+    /** Defining clause prose. */
+    prose: string;
+    /** SpecTec rule / syntax names referenced by the defining clause. */
+    formal_refs: string[];
+    /** Rendered spec URL for the defining clause. */
+    url: string;
+}
+/** Raw macro shape as emitted by src/parser/upstream.ts. */
+interface RawMacro {
+    body: string;
+    kind: "instruction" | "type" | "other";
+    category: string | null;
+    section: string;
+    anchor: string;
+}
+/**
+ * Build the type catalog. `macros` is the dumped macro table;
+ * `typeClauses` is the parsed `syntax/types` section.
+ */
+export declare function buildTypeCatalog(macros: Record<string, RawMacro>, typeClauses: SpecClause[]): TypeEntry[];
+/** Look up one type by name (case-insensitive, exact). */
+export declare function getType(catalog: TypeEntry[], name: string): TypeEntry | null;
+export {};

package/dist/parser/types.js

@@ -0,0 +1,116 @@
+// Build a type catalog from the macro table (concrete value-type
+// names) joined with the parsed `syntax/types` section clauses
+// (the prose + anchors that define each type and type form).
+//
+// Two kinds of entry:
+//   - concrete value types — `i32`, `f64`, `v128`, `funcref`, … —
+//     grouped under their category section (number / vector /
+//     reference types);
+//   - type forms — `functype`, `limits`, `memtype`, `rectype`, … —
+//     each its own clause in the types section.
+// Concrete value-type macros are tagged with these anchors. Each maps
+// to a catalog `kind`, the canonical category clause anchor, and an
+// `accept` predicate that keeps only well-formed concrete type names.
+//
+// The macro table also defines meta-variable shorthands under these
+// same anchors (`\INX` → `i`, `\FNX` → `f`, `\VNX` → `v`), lane
+// widths (`\I128` → `i128`), and reference constructors / keywords
+// (`\REF` → `ref`, `\NULL` → `null`). Those aren't value types, so
+// `accept` filters them out.
+const VALUE_TYPE_ANCHORS = {
+    "syntax-numtype": {
+        kind: "number",
+        clause: "syntax-numtype",
+        accept: (b) => /^[if](32|64)$/.test(b),
+    },
+    "syntax-vectype": {
+        kind: "vector",
+        clause: "syntax-vectype",
+        accept: (b) => b === "v128",
+    },
+    "syntax-reftype": {
+        kind: "reference",
+        clause: "syntax-reftype",
+        accept: (b) => b.endsWith("ref") && b !== "ref",
+    },
+};
+function findClause(clauses, anchor) {
+    return clauses.find((c) => c.anchors.includes(anchor));
+}
+/**
+ * Build the type catalog. `macros` is the dumped macro table;
+ * `typeClauses` is the parsed `syntax/types` section.
+ */
+export function buildTypeCatalog(macros, typeClauses) {
+    const entries = [];
+    const seen = new Set();
+    // 1. Concrete value types, grouped by category anchor.
+    const byCategory = new Map();
+    for (const macro of Object.values(macros)) {
+        if (macro.kind !== "type")
+            continue;
+        const mapping = VALUE_TYPE_ANCHORS[macro.anchor];
+        if (!mapping)
+            continue; // skip syntax-shape / syntax-valtype aliases here
+        if (!mapping.accept(macro.body))
+            continue; // drop meta-vars / keywords
+        const list = byCategory.get(mapping.clause) ?? [];
+        if (!list.includes(macro.body))
+            list.push(macro.body);
+        byCategory.set(mapping.clause, list);
+    }
+    for (const [clauseAnchor, mapping] of Object.entries(VALUE_TYPE_ANCHORS)) {
+        const members = (byCategory.get(clauseAnchor) ?? []).sort();
+        const clause = findClause(typeClauses, mapping.clause);
+        for (const name of members) {
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            entries.push({
+                name,
+                kind: mapping.kind,
+                anchor: clauseAnchor,
+                members: members.filter((m) => m !== name),
+                title: clause?.title ?? null,
+                prose: clause?.prose ?? "",
+                formal_refs: clause?.formal_refs ?? [],
+                url: clause?.url ??
+                    `https://webassembly.github.io/spec/core/syntax/types.html#${clauseAnchor}`,
+            });
+        }
+    }
+    // 2. Type forms — every `syntax-<form>` clause in the types section
+    //    that isn't already a concrete value type. Covers functype,
+    //    limits, memtype, tabletype, globaltype, rectype, heaptype,
+    //    resulttype, blocktype, externtype, etc.
+    for (const clause of typeClauses) {
+        for (const anchor of clause.anchors) {
+            const m = anchor.match(/^syntax-([a-z0-9]+)$/);
+            if (!m)
+                continue;
+            const name = m[1];
+            if (seen.has(name))
+                continue;
+            // Skip the category clauses already represented by their members.
+            if (anchor in VALUE_TYPE_ANCHORS)
+                continue;
+            seen.add(name);
+            entries.push({
+                name,
+                kind: "form",
+                anchor,
+                members: [],
+                title: clause.title,
+                prose: clause.prose,
+                formal_refs: clause.formal_refs,
+                url: clause.url,
+            });
+        }
+    }
+    return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Look up one type by name (case-insensitive, exact). */
+export function getType(catalog, name) {
+    const needle = name.trim().toLowerCase();
+    return catalog.find((t) => t.name.toLowerCase() === needle) ?? null;
+}

package/dist/parser/upstream.d.ts

@@ -0,0 +1,7 @@
+import type { RawInstruction, RawMacro, RawDump } from "./instructions.js";
+export type { RawInstruction, RawMacro, RawDump } from "./instructions.js";
+export declare function parseInstructions(source: string): RawInstruction[];
+export declare function parseMacros(text: string): Record<string, RawMacro>;
+/** Read both upstream files from a vendored checkout and produce the
+ *  combined raw dump. */
+export declare function extractRawDump(snapshotDir: string): RawDump;

package/dist/parser/upstream.js

@@ -0,0 +1,230 @@
+// Extract the structured instruction index + macro table from the
+// upstream WebAssembly/spec sources — a pure-TypeScript replacement
+// for the old scripts/dump-instructions.py, so the build needs no
+// Python toolchain.
+//
+// Two upstream files are read:
+//
+//   document/core/appendix/index-instructions.py
+//     The structured source for the appendix instruction table. We do
+//     NOT execute it; we parse the literal `INSTRUCTIONS = [ ... ]`
+//     list of `Instruction(...)` calls. Each entry's args are simple
+//     Python literals — raw strings (`r'...'`), floats, `None`, and
+//     keyword args — with no nested calls, escaped quotes, or
+//     in-string commas (verified against the pinned source).
+//
+//   document/core/util/macros.def
+//     reStructuredText `|MACRO| mathdef:: \xref{section}{anchor}
+//     {\K{body}}` lines. The `\K{...}` body is the rendered mnemonic
+//     / type string; the anchor gives the category.
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+const INSTRUCTION_KEYS = [
+    "version",
+    "name",
+    "opcode",
+    "type",
+    "validation",
+    "execution",
+    "operator",
+    "validation2",
+    "execution2",
+];
+// ─── index-instructions.py ──────────────────────────────────────────
+const QUOTES = new Set(["'", '"']);
+/**
+ * Slice out the body of the `INSTRUCTIONS = [ ... ]` list, scanning
+ * for the matching `]` while ignoring brackets inside string literals.
+ * Upstream uses both `r'...'` and `r"..."` raw strings (the latter
+ * when the content contains a single quote), so quote tracking keys
+ * off whichever quote opened the current string.
+ */
+function sliceInstructionsList(source) {
+    const marker = "INSTRUCTIONS = [";
+    const start = source.indexOf(marker);
+    if (start < 0)
+        throw new Error("INSTRUCTIONS list not found in index-instructions.py");
+    let i = start + marker.length;
+    let depth = 1;
+    let quote = null;
+    for (; i < source.length; i++) {
+        const c = source[i];
+        if (quote) {
+            if (c === quote)
+                quote = null;
+            continue;
+        }
+        if (QUOTES.has(c))
+            quote = c;
+        else if (c === "[")
+            depth++;
+        else if (c === "]") {
+            depth--;
+            if (depth === 0)
+                return source.slice(start + marker.length, i);
+        }
+    }
+    throw new Error("Unterminated INSTRUCTIONS list");
+}
+/** Extract the inner-argument text of each `Instruction(...)` call. */
+function instructionCallArgs(listBody) {
+    const calls = [];
+    const marker = "Instruction(";
+    let idx = 0;
+    while ((idx = listBody.indexOf(marker, idx)) >= 0) {
+        let i = idx + marker.length;
+        let depth = 1;
+        let quote = null;
+        const argStart = i;
+        for (; i < listBody.length; i++) {
+            const c = listBody[i];
+            if (quote) {
+                if (c === quote)
+                    quote = null;
+                continue;
+            }
+            if (QUOTES.has(c))
+                quote = c;
+            else if (c === "(")
+                depth++;
+            else if (c === ")") {
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+        }
+        calls.push(listBody.slice(argStart, i));
+        idx = i + 1;
+    }
+    return calls;
+}
+/** Split an argument list on top-level commas (ignoring those inside
+ *  string literals of either quote style). */
+function splitArgs(argText) {
+    const out = [];
+    let cur = "";
+    let quote = null;
+    for (let i = 0; i < argText.length; i++) {
+        const c = argText[i];
+        if (quote) {
+            cur += c;
+            if (c === quote)
+                quote = null;
+            continue;
+        }
+        if (QUOTES.has(c)) {
+            quote = c;
+            cur += c;
+        }
+        else if (c === ",") {
+            out.push(cur);
+            cur = "";
+        }
+        else {
+            cur += c;
+        }
+    }
+    if (cur.trim() !== "")
+        out.push(cur);
+    return out;
+}
+/** Parse a single Python literal arg value: raw/plain string (either
+ *  quote style), float, or None. */
+function parseValue(tokenRaw) {
+    const token = tokenRaw.trim();
+    if (token === "None")
+        return null;
+    // String: optional `r` prefix, then '...' or "...".
+    const m = token.match(/^r?(['"])([\s\S]*)\1$/);
+    if (m)
+        return m[2];
+    const num = Number(token);
+    if (!Number.isNaN(num))
+        return num;
+    throw new Error(`Unparseable Instruction arg: ${tokenRaw}`);
+}
+export function parseInstructions(source) {
+    const listBody = sliceInstructionsList(source);
+    const out = [];
+    for (const callArgs of instructionCallArgs(listBody)) {
+        const rec = {
+            version: null,
+            name: null,
+            opcode: null,
+            type: null,
+            validation: null,
+            execution: null,
+            operator: null,
+            validation2: null,
+            execution2: null,
+        };
+        let positional = 0;
+        for (const argRaw of splitArgs(callArgs)) {
+            const arg = argRaw.trim();
+            if (arg === "")
+                continue;
+            // Keyword arg? `name=value` where name is a bare identifier.
+            const kw = arg.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]+)$/);
+            if (kw && !kw[1].startsWith("r'")) {
+                const key = kw[1];
+                if (key in rec)
+                    rec[key] = parseValue(kw[2]);
+                continue;
+            }
+            const key = INSTRUCTION_KEYS[positional++];
+            if (key)
+                rec[key] = parseValue(arg);
+        }
+        out.push(rec);
+    }
+    return out;
+}
+// ─── macros.def ─────────────────────────────────────────────────────
+// `.. |NAME| mathdef:: \xref{section}{anchor}{\K{body}}` — body may
+// nest one level of braces (e.g. `\K{local{.}get}`).
+const MACRO_RE = /^\.\.\s+\|([A-Z0-9]+)\|\s+mathdef::\s+\\xref\{([^}]+)\}\{([^}]+)\}\{\\K\{((?:[^{}]+|\{[^{}]*\})+)\}\}\s*$/;
+const TYPE_ANCHORS = new Set([
+    "syntax-numtype",
+    "syntax-vectype",
+    "syntax-reftype",
+    "syntax-valtype",
+    "syntax-shape",
+]);
+function cleanBody(body) {
+    let cleaned = body.replace(/\\_/g, "_").replace(/\{\.\}/g, ".");
+    cleaned = cleaned.replace(/\\scriptstyle\s*/g, "");
+    cleaned = cleaned.replace(/\\;/g, "");
+    cleaned = cleaned.replace(/\{(\d+)\}/g, "$1");
+    return cleaned;
+}
+export function parseMacros(text) {
+    const macros = {};
+    for (const line of text.split("\n")) {
+        const m = line.match(MACRO_RE);
+        if (!m)
+            continue;
+        const [, name, section, anchor, bodyRaw] = m;
+        let kind = "other";
+        let category = null;
+        if (anchor.startsWith("syntax-instr-")) {
+            kind = "instruction";
+            category = anchor.slice("syntax-instr-".length);
+        }
+        else if (TYPE_ANCHORS.has(anchor)) {
+            kind = "type";
+        }
+        macros[name] = { body: cleanBody(bodyRaw), kind, category, section: section, anchor: anchor };
+    }
+    return macros;
+}
+// ─── driver ─────────────────────────────────────────────────────────
+/** Read both upstream files from a vendored checkout and produce the
+ *  combined raw dump. */
+export function extractRawDump(snapshotDir) {
+    const instrPath = resolve(snapshotDir, "document/core/appendix/index-instructions.py");
+    const macrosPath = resolve(snapshotDir, "document/core/util/macros.def");
+    return {
+        instructions: parseInstructions(readFileSync(instrPath, "utf8")),
+        macros: parseMacros(readFileSync(macrosPath, "utf8")),
+    };
+}

package/dist/paths.d.ts

@@ -0,0 +1,3 @@
+export declare const REPO_ROOT: string;
+export declare const BUILD_DIR: string;
+export declare const VENDOR_ROOT: string;

package/dist/paths.js

@@ -0,0 +1,12 @@
+// Resolved at module load. Used by build-time scripts and the runtime
+// server to locate the baked `build/` artifacts relative to the
+// repository root (in dev) or the published package (in dist).
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+const HERE = dirname(fileURLToPath(import.meta.url));
+// In dev:  src/paths.ts          → repo-root is `../`.
+// In dist: dist/paths.js         → repo-root is `../`.
+// Either way one `..` lands us at the project root.
+export const REPO_ROOT = resolve(HERE, "..");
+export const BUILD_DIR = resolve(REPO_ROOT, "build");
+export const VENDOR_ROOT = resolve(REPO_ROOT, "vendor");

package/dist/spec/catalog.d.ts

@@ -0,0 +1,10 @@
+import type { SpecVersion } from "../versions.js";
+export declare const SPEC_NAMES: readonly ["core", "js-api", "web-api"];
+export type SpecName = (typeof SPEC_NAMES)[number];
+/** Specs that have a section index (all of them). */
+export declare const SECTION_SPECS: readonly ["core", "js-api", "web-api"];
+/** Filename (within build/) for the unified core snapshot. */
+export declare function buildArtifactName(spec: "core", version: SpecVersion): string;
+/** Filename (within build/) for an auxiliary spec's section index
+ *  (js-api / web-api). */
+export declare function sectionsArtifactName(spec: SpecName, version: SpecVersion): string;

package/dist/spec/catalog.js

@@ -0,0 +1,20 @@
+// Spec catalog — what (spec, version) pairs the server claims to
+// support, and what build artifact each one corresponds to. Kept
+// dependency-free so the Cloudflare Worker can bundle it.
+// The WebAssembly/spec repo carries three specifications under
+// /document/. `core` is the first-class target (instructions, types,
+// validation, execution, formats); `js-api` and `web-api` are the
+// JavaScript + Web embedding specs, covered by the section/search
+// tools.
+export const SPEC_NAMES = ["core", "js-api", "web-api"];
+/** Specs that have a section index (all of them). */
+export const SECTION_SPECS = SPEC_NAMES;
+/** Filename (within build/) for the unified core snapshot. */
+export function buildArtifactName(spec, version) {
+    return `wasm-spec-${spec}-${version}.json`;
+}
+/** Filename (within build/) for an auxiliary spec's section index
+ *  (js-api / web-api). */
+export function sectionsArtifactName(spec, version) {
+    return `wasm-sections-${spec}-${version}.json`;
+}