wasm-mcp 0.1.0

package/dist/spec/instructions_query.d.ts

@@ -0,0 +1,46 @@
+import type { InstructionRecord, InstructionCategory } from "../parser/instructions.js";
+/** A lightweight row returned by list / search (no signature/anchors). */
+export interface InstructionSummary {
+    mnemonic: string;
+    opcodes: number[];
+    category: InstructionCategory;
+    version: string;
+}
+export declare function toSummary(r: InstructionRecord): InstructionSummary;
+/** Format a byte array as the conventional space-separated hex string,
+ *  e.g. `[0xFD, 0x89, 0x02]` → `"0xfd 0x89 0x02"`. */
+export declare function formatOpcode(opcodes: number[]): string;
+/** Parse a user-supplied opcode string into a byte array. Accepts
+ *  `"0x6a"`, `"6a"`, `"0xFD 0x89 0x02"`, `"fd 89 02"`, `"fd,89,02"`.
+ *  Returns null if any token isn't a 0–255 hex byte. */
+export declare function parseOpcodeQuery(input: string): number[] | null;
+/**
+ * Look up one instruction by mnemonic (exact, case-insensitive) or
+ * by binary opcode. Mnemonic is tried first; if the query parses as
+ * a byte sequence, an exact opcode match is tried too. Returns the
+ * matched record or null.
+ */
+export declare function getInstruction(records: InstructionRecord[], query: {
+    mnemonic?: string;
+    opcode?: string;
+}): InstructionRecord | null;
+export interface ListFilter {
+    category?: InstructionCategory;
+    version?: string;
+    /** Substring matched against the mnemonic prefix, case-insensitive. */
+    prefix?: string;
+}
+/** Enumerate instructions, optionally filtered, sorted by opcode. */
+export declare function listInstructions(records: InstructionRecord[], filter?: ListFilter): InstructionSummary[];
+export interface InstructionSearchHit extends InstructionSummary {
+    /** Which field produced the strongest match. */
+    matched_on: "mnemonic-exact" | "mnemonic-substring" | "category" | "opcode";
+    /** Relevance score (0–100). Higher = stronger. */
+    score: number;
+}
+/**
+ * Search instructions by free-text query. Matches the mnemonic
+ * (exact > substring), the category name, and the formatted opcode.
+ * Ranked highest-first; ties broken by opcode order.
+ */
+export declare function searchInstructions(records: InstructionRecord[], query: string, limit?: number): InstructionSearchHit[];

package/dist/spec/instructions_query.js

@@ -0,0 +1,120 @@
+// Pure query logic for the instruction index, shared by the stdio
+// server and (later) the Cloudflare Worker so both rank and filter
+// identically. Dependency-free — no node:fs, no parser imports — so
+// the Worker can bundle it directly. Callers pass in the already
+// loaded instruction records.
+export function toSummary(r) {
+    return { mnemonic: r.mnemonic, opcodes: r.opcodes, category: r.category, version: r.version };
+}
+/** Format a byte array as the conventional space-separated hex string,
+ *  e.g. `[0xFD, 0x89, 0x02]` → `"0xfd 0x89 0x02"`. */
+export function formatOpcode(opcodes) {
+    return opcodes.map((b) => `0x${b.toString(16).padStart(2, "0")}`).join(" ");
+}
+/** Parse a user-supplied opcode string into a byte array. Accepts
+ *  `"0x6a"`, `"6a"`, `"0xFD 0x89 0x02"`, `"fd 89 02"`, `"fd,89,02"`.
+ *  Returns null if any token isn't a 0–255 hex byte. */
+export function parseOpcodeQuery(input) {
+    const tokens = input
+        .trim()
+        .toLowerCase()
+        .split(/[\s,]+/)
+        .filter((t) => t.length > 0);
+    if (tokens.length === 0)
+        return null;
+    const bytes = [];
+    for (const tok of tokens) {
+        const hex = tok.startsWith("0x") ? tok.slice(2) : tok;
+        if (!/^[0-9a-f]{1,2}$/.test(hex))
+            return null;
+        bytes.push(parseInt(hex, 16));
+    }
+    return bytes;
+}
+function opcodesEqual(a, b) {
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+/**
+ * Look up one instruction by mnemonic (exact, case-insensitive) or
+ * by binary opcode. Mnemonic is tried first; if the query parses as
+ * a byte sequence, an exact opcode match is tried too. Returns the
+ * matched record or null.
+ */
+export function getInstruction(records, query) {
+    if (query.mnemonic !== undefined) {
+        const needle = query.mnemonic.trim().toLowerCase();
+        const byMnemonic = records.find((r) => r.mnemonic.toLowerCase() === needle);
+        if (byMnemonic)
+            return byMnemonic;
+    }
+    if (query.opcode !== undefined) {
+        const bytes = parseOpcodeQuery(query.opcode);
+        if (bytes) {
+            const byOpcode = records.find((r) => opcodesEqual(r.opcodes, bytes));
+            if (byOpcode)
+                return byOpcode;
+        }
+    }
+    return null;
+}
+/** Enumerate instructions, optionally filtered, sorted by opcode. */
+export function listInstructions(records, filter = {}) {
+    let out = records;
+    if (filter.category !== undefined)
+        out = out.filter((r) => r.category === filter.category);
+    if (filter.version !== undefined)
+        out = out.filter((r) => r.version === filter.version);
+    if (filter.prefix !== undefined) {
+        const p = filter.prefix.toLowerCase();
+        out = out.filter((r) => r.mnemonic.toLowerCase().startsWith(p));
+    }
+    return [...out]
+        .sort((a, b) => compareOpcodes(a.opcodes, b.opcodes))
+        .map(toSummary);
+}
+function compareOpcodes(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return a.length - b.length;
+}
+/**
+ * Search instructions by free-text query. Matches the mnemonic
+ * (exact > substring), the category name, and the formatted opcode.
+ * Ranked highest-first; ties broken by opcode order.
+ */
+export function searchInstructions(records, query, limit = 20) {
+    const q = query.trim().toLowerCase();
+    if (q === "")
+        return [];
+    const opcodeBytes = parseOpcodeQuery(q);
+    const hits = [];
+    for (const r of records) {
+        const mn = r.mnemonic.toLowerCase();
+        let matched_on = null;
+        let score = 0;
+        if (mn === q) {
+            matched_on = "mnemonic-exact";
+            score = 100;
+        }
+        else if (mn.includes(q)) {
+            matched_on = "mnemonic-substring";
+            // Earlier matches rank higher; shorter mnemonics rank higher.
+            score = 70 - mn.indexOf(q) - Math.min(20, mn.length - q.length);
+        }
+        else if (r.category === q) {
+            matched_on = "category";
+            score = 40;
+        }
+        else if (opcodeBytes && opcodesEqual(r.opcodes, opcodeBytes)) {
+            matched_on = "opcode";
+            score = 90;
+        }
+        if (matched_on)
+            hits.push({ ...toSummary(r), matched_on, score });
+    }
+    hits.sort((a, b) => b.score - a.score || compareOpcodes(a.opcodes, b.opcodes));
+    return hits.slice(0, limit);
+}

package/dist/spec/pin.d.ts

@@ -0,0 +1,13 @@
+export interface SpecPin {
+    /** Repo key, e.g. `spec/main`. */
+    readonly key: string;
+    /** Full upstream commit SHA. */
+    readonly sha: string;
+}
+/**
+ * Parse vendor/PINNED.txt. Throws if the file is missing or empty.
+ * Pure read; no network, no fetch.
+ */
+export declare function readPins(file?: string): SpecPin[];
+/** Look up a single pin by key. */
+export declare function getPin(key: string, pins?: SpecPin[]): SpecPin;

package/dist/spec/pin.js

@@ -0,0 +1,39 @@
+// Read the pinned upstream SHAs from `vendor/PINNED.txt`. Used by
+// build-time scripts and by the runtime `spec_version` tool (the
+// build pipeline copies the parsed pin into each baked JSON
+// artifact, so the runtime never reads `vendor/` directly).
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { VENDOR_ROOT } from "../paths.js";
+/**
+ * Parse vendor/PINNED.txt. Throws if the file is missing or empty.
+ * Pure read; no network, no fetch.
+ */
+export function readPins(file = resolve(VENDOR_ROOT, "PINNED.txt")) {
+    const text = readFileSync(file, "utf8");
+    const pins = [];
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (line === "" || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq < 0)
+            continue;
+        const key = line.slice(0, eq).trim();
+        const sha = line.slice(eq + 1).trim();
+        if (key && sha)
+            pins.push({ key, sha });
+    }
+    if (pins.length === 0) {
+        throw new Error(`No pins found in ${file}`);
+    }
+    return pins;
+}
+/** Look up a single pin by key. */
+export function getPin(key, pins = readPins()) {
+    const found = pins.find((p) => p.key === key);
+    if (!found) {
+        throw new Error(`Pin not found: ${key} (have: ${pins.map((p) => p.key).join(", ")})`);
+    }
+    return found;
+}

package/dist/spec/proposals_query.d.ts

@@ -0,0 +1,15 @@
+import type { Proposal, ProposalStatus } from "../parser/proposals.js";
+export interface ProposalFilter {
+    /** Filter by lifecycle status (`phase-3`, `finished`, `inactive`, …). */
+    status?: ProposalStatus;
+    /** Filter by numeric phase 0–5. */
+    phase?: number;
+    /** Champion substring, case-insensitive. */
+    champion?: string;
+    /** Affected-spec filter (`core`, `js-api`, `web-api`) — finished only. */
+    affects?: string;
+    /** Name / champion substring, case-insensitive. */
+    contains?: string;
+}
+/** Filter + sort the proposal list. Sorted by phase desc, then name. */
+export declare function listProposals(proposals: Proposal[], filter?: ProposalFilter): Proposal[];

package/dist/spec/proposals_query.js

@@ -0,0 +1,23 @@
+// Pure query logic for the proposals index. Dependency-free; callers
+// pass in the already-loaded proposal list.
+/** Filter + sort the proposal list. Sorted by phase desc, then name. */
+export function listProposals(proposals, filter = {}) {
+    let out = proposals;
+    if (filter.status !== undefined)
+        out = out.filter((p) => p.status === filter.status);
+    if (filter.phase !== undefined)
+        out = out.filter((p) => p.phase === filter.phase);
+    if (filter.champion !== undefined) {
+        const c = filter.champion.toLowerCase();
+        out = out.filter((p) => p.champion.toLowerCase().includes(c));
+    }
+    if (filter.affects !== undefined) {
+        const a = filter.affects.toLowerCase();
+        out = out.filter((p) => p.affected_specs.some((s) => s.toLowerCase() === a));
+    }
+    if (filter.contains !== undefined) {
+        const q = filter.contains.toLowerCase();
+        out = out.filter((p) => p.name.toLowerCase().includes(q) || p.champion.toLowerCase().includes(q));
+    }
+    return [...out].sort((a, b) => (b.phase ?? -1) - (a.phase ?? -1) || a.name.localeCompare(b.name));
+}

package/dist/spec/sections_query.d.ts

@@ -0,0 +1,43 @@
+import type { SpecClause } from "../parser/sections.js";
+/** Lightweight section row for list / search results. */
+export interface SectionSummary {
+    id: string;
+    anchors: string[];
+    title: string | null;
+    level: number;
+    path: string;
+    url: string;
+}
+export declare function toSectionSummary(c: SpecClause): SectionSummary;
+/**
+ * Fetch one clause by id or by any of its anchors (exact,
+ * case-sensitive — anchors are stable lowercase fragment ids).
+ */
+export declare function getClause(clauses: SpecClause[], idOrAnchor: string): SpecClause | null;
+export interface SectionListFilter {
+    /** Source-path prefix, e.g. `exec`, `binary`, `syntax/types`. */
+    path?: string;
+    /** Only clauses whose primary anchor / id starts with this prefix. */
+    anchor_prefix?: string;
+    /** Only clauses with a heading (drop anchor-only content blocks). */
+    titled_only?: boolean;
+    /** Cap heading depth (1 = page titles only). */
+    max_level?: number;
+}
+/** Enumerate sections, optionally filtered. Preserves source order. */
+export declare function listSections(clauses: SpecClause[], filter?: SectionListFilter): SectionSummary[];
+export interface SpecSearchHit extends SectionSummary {
+    /** Which field produced the strongest match. */
+    matched_on: "anchor-exact" | "title" | "anchor" | "prose";
+    /** Relevance score (0–100). Higher = stronger. */
+    score: number;
+    /** A short prose snippet around the first match, when matched in prose. */
+    snippet?: string;
+}
+/**
+ * Full-text-ish search over the section index. Ranking (high → low):
+ *   exact anchor/id match > title substring > anchor substring >
+ *   prose substring. Returns lightweight hits; follow up with
+ *   section_get for the full clause.
+ */
+export declare function searchSpec(clauses: SpecClause[], query: string, limit?: number): SpecSearchHit[];

package/dist/spec/sections_query.js

@@ -0,0 +1,89 @@
+// Pure query logic for the section index, shared by the stdio server
+// and (later) the Cloudflare Worker. Dependency-free — callers pass
+// in the already-loaded clauses.
+export function toSectionSummary(c) {
+    return { id: c.id, anchors: c.anchors, title: c.title, level: c.level, path: c.path, url: c.url };
+}
+/**
+ * Fetch one clause by id or by any of its anchors (exact,
+ * case-sensitive — anchors are stable lowercase fragment ids).
+ */
+export function getClause(clauses, idOrAnchor) {
+    const needle = idOrAnchor.trim();
+    return (clauses.find((c) => c.id === needle || c.anchors.includes(needle)) ??
+        // Fall back to case-insensitive match for convenience.
+        clauses.find((c) => c.id.toLowerCase() === needle.toLowerCase() ||
+            c.anchors.some((a) => a.toLowerCase() === needle.toLowerCase())) ??
+        null);
+}
+/** Enumerate sections, optionally filtered. Preserves source order. */
+export function listSections(clauses, filter = {}) {
+    let out = clauses;
+    if (filter.path !== undefined) {
+        const p = filter.path;
+        out = out.filter((c) => c.path === p || c.path.startsWith(p + "/"));
+    }
+    if (filter.anchor_prefix !== undefined) {
+        const p = filter.anchor_prefix.toLowerCase();
+        out = out.filter((c) => c.id.toLowerCase().startsWith(p) || c.anchors.some((a) => a.toLowerCase().startsWith(p)));
+    }
+    if (filter.titled_only)
+        out = out.filter((c) => c.title !== null);
+    if (filter.max_level !== undefined) {
+        const max = filter.max_level;
+        // level 0 = anchor-only blocks; keep them unless titled_only set.
+        out = out.filter((c) => c.level === 0 || c.level <= max);
+    }
+    return out.map(toSectionSummary);
+}
+function snippetAround(prose, needle, radius = 80) {
+    const idx = prose.toLowerCase().indexOf(needle);
+    if (idx < 0)
+        return prose.slice(0, radius * 2).trim();
+    const start = Math.max(0, idx - radius);
+    const end = Math.min(prose.length, idx + needle.length + radius);
+    return (start > 0 ? "…" : "") + prose.slice(start, end).trim() + (end < prose.length ? "…" : "");
+}
+/**
+ * Full-text-ish search over the section index. Ranking (high → low):
+ *   exact anchor/id match > title substring > anchor substring >
+ *   prose substring. Returns lightweight hits; follow up with
+ *   section_get for the full clause.
+ */
+export function searchSpec(clauses, query, limit = 20) {
+    const q = query.trim().toLowerCase();
+    if (q === "")
+        return [];
+    const hits = [];
+    for (const c of clauses) {
+        const idLower = c.id.toLowerCase();
+        const anchorsLower = c.anchors.map((a) => a.toLowerCase());
+        const titleLower = (c.title ?? "").toLowerCase();
+        const proseLower = c.prose.toLowerCase();
+        let matched_on = null;
+        let score = 0;
+        let snippet;
+        if (idLower === q || anchorsLower.includes(q)) {
+            matched_on = "anchor-exact";
+            score = 100;
+        }
+        else if (titleLower.includes(q)) {
+            matched_on = "title";
+            score = 80 - titleLower.indexOf(q);
+        }
+        else if (anchorsLower.some((a) => a.includes(q)) || idLower.includes(q)) {
+            matched_on = "anchor";
+            score = 55;
+        }
+        else if (proseLower.includes(q)) {
+            matched_on = "prose";
+            score = 40 - Math.min(20, Math.floor(proseLower.indexOf(q) / 50));
+            snippet = snippetAround(c.prose, q);
+        }
+        if (matched_on) {
+            hits.push({ ...toSectionSummary(c), matched_on, score, ...(snippet ? { snippet } : {}) });
+        }
+    }
+    hits.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+    return hits.slice(0, limit);
+}

package/dist/spec/spec_data.d.ts

@@ -0,0 +1,46 @@
+import { type SpecName } from "./catalog.js";
+import { type VersionValue } from "../versions.js";
+import type { InstructionRecord } from "../parser/instructions.js";
+import type { SpecClause } from "../parser/sections.js";
+import type { TypeEntry } from "../parser/types.js";
+import type { Proposal } from "../parser/proposals.js";
+export interface LoadedSnapshot {
+    pin: {
+        key: string;
+        sha: string;
+        spec: "core";
+        version: string;
+    };
+    instructions: InstructionRecord[];
+    sections: SpecClause[];
+    types: TypeEntry[];
+    report: Record<string, number>;
+}
+/**
+ * Load (and cache) the baked snapshot for a given version selector.
+ * Throws if the artifact is missing — that means the build pipeline
+ * didn't run, which is a packaging error, not a user error.
+ */
+export declare function loadSnapshot(version?: VersionValue): LoadedSnapshot;
+/** Convenience accessors for a version. */
+export declare function loadInstructions(version?: VersionValue): InstructionRecord[];
+/**
+ * Load the section index for a given spec. `core` comes from the
+ * unified core snapshot; `js-api` / `web-api` come from their own
+ * baked Bikeshed artifacts (separate files, same upstream pin).
+ */
+export declare function loadSections(spec?: SpecName, version?: VersionValue): SpecClause[];
+export declare function loadTypes(version?: VersionValue): TypeEntry[];
+/** Test/Worker seam: inject a snapshot directly, bypassing the file read. */
+export declare function primeCache(version: string, snapshot: LoadedSnapshot): void;
+export interface LoadedProposals {
+    pin: {
+        key: string;
+        sha: string;
+        repo: "proposals";
+        version: string;
+    };
+    proposals: Proposal[];
+}
+export declare function loadProposals(version?: string): LoadedProposals;
+export declare function primeProposalsCache(version: string, loaded: LoadedProposals): void;

package/dist/spec/spec_data.js

@@ -0,0 +1,92 @@
+// Runtime loader for the unified baked artifact. Reads
+// `build/wasm-spec-core-<version>.json` (produced at build time by
+// src/index/build_spec.ts) once per version and caches the parsed
+// result in-memory. Pure local read — no network, no writes.
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { BUILD_DIR } from "../paths.js";
+import { buildArtifactName, sectionsArtifactName } from "./catalog.js";
+import { resolveVersion } from "../versions.js";
+const cache = new Map();
+/**
+ * Load (and cache) the baked snapshot for a given version selector.
+ * Throws if the artifact is missing — that means the build pipeline
+ * didn't run, which is a packaging error, not a user error.
+ */
+export function loadSnapshot(version) {
+    const v = resolveVersion(version);
+    const cached = cache.get(v);
+    if (cached)
+        return cached;
+    const file = resolve(BUILD_DIR, buildArtifactName("core", v));
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (err) {
+        throw new Error(`Baked spec artifact not found: ${file}. ` +
+            `Run \`npm run fetch-spec && npm run build-spec\` to generate it. (${String(err)})`);
+    }
+    const snapshot = JSON.parse(raw);
+    cache.set(v, snapshot);
+    return snapshot;
+}
+/** Convenience accessors for a version. */
+export function loadInstructions(version) {
+    return loadSnapshot(version).instructions;
+}
+/**
+ * Load the section index for a given spec. `core` comes from the
+ * unified core snapshot; `js-api` / `web-api` come from their own
+ * baked Bikeshed artifacts (separate files, same upstream pin).
+ */
+export function loadSections(spec = "core", version) {
+    if (spec === "core")
+        return loadSnapshot(version).sections;
+    const v = resolveVersion(version);
+    const key = `${spec}:${v}`;
+    const cached = auxSectionsCache.get(key);
+    if (cached)
+        return cached;
+    const file = resolve(BUILD_DIR, sectionsArtifactName(spec, v));
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (err) {
+        throw new Error(`Baked sections artifact not found: ${file}. ` +
+            `Run \`npm run fetch-spec && npm run build-spec\` to generate it. (${String(err)})`);
+    }
+    const parsed = JSON.parse(raw);
+    auxSectionsCache.set(key, parsed.sections);
+    return parsed.sections;
+}
+const auxSectionsCache = new Map();
+export function loadTypes(version) {
+    return loadSnapshot(version).types;
+}
+/** Test/Worker seam: inject a snapshot directly, bypassing the file read. */
+export function primeCache(version, snapshot) {
+    cache.set(version, snapshot);
+}
+const proposalsCache = new Map();
+export function loadProposals(version = "main") {
+    const cached = proposalsCache.get(version);
+    if (cached)
+        return cached;
+    const file = resolve(BUILD_DIR, `wasm-proposals-${version}.json`);
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (err) {
+        throw new Error(`Baked proposals artifact not found: ${file}. ` +
+            `Run \`npm run fetch-spec && npm run build-spec\` to generate it. (${String(err)})`);
+    }
+    const loaded = JSON.parse(raw);
+    proposalsCache.set(version, loaded);
+    return loaded;
+}
+export function primeProposalsCache(version, loaded) {
+    proposalsCache.set(version, loaded);
+}

package/dist/spec/tool_inventory.d.ts

@@ -0,0 +1,5 @@
+export declare const HOSTED_TOOLS: readonly ["spec_version", "instruction_get", "instruction_list", "instruction_search", "type_get", "section_get", "section_list", "spec_search", "proposal_list"];
+export type HostedToolName = (typeof HOSTED_TOOLS)[number];
+export declare const STDIO_ONLY_TOOLS: readonly [];
+export type StdioOnlyToolName = (typeof STDIO_ONLY_TOOLS)[number];
+export declare const TOTAL_TOOL_COUNT: number;

package/dist/spec/tool_inventory.js

@@ -0,0 +1,17 @@
+// Canonical list of tool names exposed by the server. Used by the
+// server-instructions string so the count stays in sync with the
+// actual registrations, and (later) by the Worker to filter to the
+// hosted-safe subset.
+export const HOSTED_TOOLS = [
+    "spec_version",
+    "instruction_get",
+    "instruction_list",
+    "instruction_search",
+    "type_get",
+    "section_get",
+    "section_list",
+    "spec_search",
+    "proposal_list",
+];
+export const STDIO_ONLY_TOOLS = [];
+export const TOTAL_TOOL_COUNT = HOSTED_TOOLS.length + STDIO_ONLY_TOOLS.length;

package/dist/versions.d.ts

@@ -0,0 +1,12 @@
+export declare const SUPPORTED_VERSIONS: readonly ["main"];
+export type SpecVersion = (typeof SUPPORTED_VERSIONS)[number];
+export declare const VERSION_ALIASES: readonly ["latest"];
+export type VersionAlias = (typeof VERSION_ALIASES)[number];
+export declare const VERSION_VALUES: readonly ["main", "latest"];
+export type VersionValue = (typeof VERSION_VALUES)[number];
+/**
+ * Resolve a public version selector to the on-disk version key.
+ * For now `latest` maps to `main`; once a stable release (e.g. 3.0)
+ * is pinned, `latest` shifts to that without callers changing.
+ */
+export declare function resolveVersion(v: VersionValue | undefined): SpecVersion;

package/dist/versions.js

@@ -0,0 +1,22 @@
+// Wasm spec version catalog.
+//
+// Unlike ECMA-262 (which publishes annual editions), the WebAssembly
+// core specification publishes named releases (1.0, 2.0, 3.0). For
+// the MVP we serve only the current working draft (`main`) pinned to
+// a specific commit; release branches can be added here when needed
+// without touching tool code.
+//
+// Kept dependency-free so the Cloudflare Worker can bundle it.
+export const SUPPORTED_VERSIONS = ["main"];
+export const VERSION_ALIASES = ["latest"];
+export const VERSION_VALUES = [...SUPPORTED_VERSIONS, ...VERSION_ALIASES];
+/**
+ * Resolve a public version selector to the on-disk version key.
+ * For now `latest` maps to `main`; once a stable release (e.g. 3.0)
+ * is pinned, `latest` shifts to that without callers changing.
+ */
+export function resolveVersion(v) {
+    if (v === undefined || v === "latest")
+        return "main";
+    return v;
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "wasm-mcp",
+  "version": "0.1.0",
+  "mcpName": "io.github.xyzzylabs/wasm-mcp",
+  "private": false,
+  "description": "Unofficial MCP server for the WebAssembly core specification — SHA-pinned instructions, types, sections, and search. Not affiliated with the W3C WebAssembly CG.",
+  "type": "module",
+  "bin": {
+    "wasm-mcp": "dist/mcp/server.js"
+  },
+  "files": [
+    "dist/mcp/",
+    "dist/spec/",
+    "dist/parser/",
+    "dist/paths.js",
+    "dist/paths.d.ts",
+    "dist/versions.js",
+    "dist/versions.d.ts",
+    "build/wasm-spec-core-main.json",
+    "build/wasm-sections-js-api-main.json",
+    "build/wasm-sections-web-api-main.json",
+    "build/wasm-proposals-main.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc && chmod +x dist/mcp/server.js",
+    "typecheck": "tsc --noEmit",
+    "fetch-spec": "bash scripts/fetch-spec.sh",
+    "build-spec": "bash scripts/build-spec.sh",
+    "parse": "tsx src/parser/cli.ts",
+    "mcp": "tsx src/mcp/server.ts",
+    "refresh": "tsx src/refresh/run.ts",
+    "docs:data": "tsx src/docs/build_docs.ts",
+    "docs:dev": "npm run docs:data && vitepress dev docs",
+    "docs:build": "npm run docs:data && vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "worker:assets": "npm run docs:build && rm -rf worker/public && cp -r docs/.vitepress/dist worker/public",
+    "test": "vitest run --testTimeout=30000",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "cheerio": "^1.0.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.0",
+    "vitepress": "^1.6.4",
+    "vitest": "^4.1.7"
+  },
+  "keywords": [
+    "webassembly",
+    "wasm",
+    "specification",
+    "language-spec",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xyzzylabs/wasm-mcp.git"
+  },
+  "license": "MIT",
+  "author": "xyzzylabs"
+}