TC39 Specs (ECMA-262 + ECMA-402)

Especificações ECMA-262 e ECMA-402 analisadas via MCP — cláusulas, etapas de algoritmo, referências cruzadas, diferenças entre edições, busca em test262 e propostas.

GitHub

Experimente este MCPPatrocinado

Documentação

tc39-mcp

📖 Docs: mcp.xyzzylabs.ai/tc39 — Comece aqui · Ferramentas · Livro de receitas · Edições · Arquitetura · Hospedagem

Projeto independente — não é uma publicação oficial da Ecma International ou do TC39. Lê as especificações ECMAScript publicamente divulgadas (ECMA-262 + ECMA-402).

Dê aos agentes de IA que falam MCP acesso estrutural à especificação JS. Qualquer cliente que fale o Model Context Protocol pode chamar clause.get sec-tonumber e receber JSON analisado (passos de algoritmos como arrays discretos, referências cruzadas como ids, assinaturas como valores tipados) em vez de receber um spec.html de 4 MB para pesquisar. As ferramentas cobrem ECMA-262 (a linguagem principal) e ECMA-402 (a API Intl): cláusulas, passos de algoritmos, referências cruzadas em ambas as direções, diffs de edições, histórico git upstream, busca em test262, consulta de propostas. Cada resposta é fixada por SHA a um commit upstream específico, para que qualquer coisa citada por um agente permaneça reproduzível.

Os snapshots são resolvidos por uma cadeia de cache local → Worker hospedado → fallback empacotado. O transporte stdio (npx tc39-mcp) busca cada snapshot do Cloudflare Worker hospedado em um cache frio, grava-o em ~/.cache/tc39-mcp/ e o serve a partir do disco daí em diante — revalidando apenas quando a cópia local é mais antiga que ~4 horas (uma requisição If-None-Match condicional). O pacote npm também inclui as edições estáveis mais recentes + main de ambas as especificações, além dos índices test262 e de propostas; quando o Worker está inalcançável, esses são servidos diretamente do pacote (o fallback offline — não gravado no cache). O Worker hospedado também é a alternativa HTTP quando você quer um endpoint de rede compartilhado; seus dados R2 são atualizados a partir do upstream a cada ~4 horas.

Instalação + primeira chamada

Conecte-o a qualquer cliente MCP — o comando de inicialização stdio é o mesmo em todos os lugares, apenas o arquivo de configuração difere:

{
  "mcpServers": {
    "tc39": { "command": "npx", "args": ["tc39-mcp"] }
  }
}

Uma instalação global também funciona — npm i -g tc39-mcp, depois execute tc39-mcp.

A primeira execução baixa o pacote npm (edições estáveis mais recentes + main, além dos índices de propostas e test262, são incluídas). A primeira chamada para um determinado snapshot o busca do Worker hospedado e o armazena em cache localmente; chamadas subsequentes são servidas do disco, revalidadas contra o Worker apenas após a janela de atualização de ~4 horas. Se o Worker estiver inalcançável, as edições empacotadas ainda respondem offline. Então, no seu cliente:

use clause.get para ler sec-tonumber e me mostre os passos

Você deve ver JSON estruturado de volta:

{
  "meta": {
    "id": "sec-tonumber",
    "aoid": "ToNumber",
    "title": "ToNumber ( argument )",
    "number": "7.1.4",
    "kind": "op"
  },
  "signatureRaw": "ToNumber ( _argument_: an ECMAScript language value, ): either a normal completion containing a Number or a throw completion",
  "algorithms": [
    { "steps": [
        { "text": "If _argument_ is a Number, return _argument_." },
        { "text": "If _argument_ is either *undefined* or a Symbol, throw a *TypeError* exception." },
        { "text": "If _argument_ is *null*, return *+0*<sub>𝔽</sub>." },
        "..."
    ]}
  ],
  "crossrefs": ["sec-tonumber-applied-to-the-string-type", "..."]
}

Passo a passo de cinco minutos: docs/getting-started.md.

HTTP hospedado

Aponte seu cliente para o Cloudflare Worker hospedado em vez de executar um subprocesso local — mesmo protocolo MCP, sem instalação:

{
  "mcpServers": {
    "tc39": {
      "type": "http",
      "url": "https://mcp.xyzzylabs.ai/tc39/mcp"
    }
  }
}

O tráfego é limitado a 30 req/min por IP.

No que ele é bom

Permitir que um agente raciocine sobre a especificação sem alucinar. Respostas JSON estruturadas fundamentam o modelo no texto real da especificação: numeração de passos, alvos de referências cruzadas, formatos de assinatura, deltas de edições, testes de conformidade. Qualquer coisa citada resolve para um id de cláusula específico em um SHA específico — fácil de verificar, fácil de reproduzir.
Encontrar a cláusula que você quer a partir de uma dica. spec.search classifica correspondências exatas de AOID primeiro; spec.symbol_resolve decodifica [[Prototype]] / %Object.prototype% / ~enumerate~.
Seguir referências em ambas as direções. spec.crossrefs retorna o que uma cláusula cita E quem a cita. Densificado por AOID, então menções simples no texto dos passos contam, não apenas hrefs <emu-xref>. include_cross_spec resolve saltos 262 ↔ 402. (Receita 1 do livro de receitas.)
Comparar edições e rastrear deriva de prosa. spec.diff entre quaisquer duas edições até ES2016; spec.history percorre o log git upstream via busca pickaxe. (Receita 2 do livro de receitas.)
Encontrar cobertura test262 para uma cláusula. test262.search com esid: de prefixo correspondente captura sec-tonumber E sec-tonumber-applied-to-the-string-type em uma única chamada.
Mapear propostas para a especificação. proposal.list / proposal.get a partir de um índice estruturado de tc39/proposals, cobrindo propostas tanto ECMA-262 quanto ECMA-402 (Intl) — filtre por spec. Atualizado no mesmo ritmo de 4 horas das especificações.
Cache local, fallback empacotado (stdio). Uma vez que um snapshot é armazenado em cache em ~/.cache/tc39-mcp/, as chamadas de ferramenta são servidas do disco e apenas revalidadas contra o Worker hospedado após a janela de atualização de ~4 horas (uma requisição If-None-Match condicional que carrega a chave do objeto R2, nunca um id de cláusula). Edições empacotadas respondem offline quando o Worker está inalcançável. O Worker hospedado é a alternativa HTTP para uso compartilhado / multi-tenant.

Ferramentas (19 em 5 namespaces)

Objetivo	Ferramenta(s)
Verificar o que está sendo servido	`spec.about` · `spec.snapshots`
Ler uma cláusula específica	`clause.get`
Encontrar uma cláusula a partir de um nome / sintoma	`spec.search` · `spec.global_search`
Resolver notação `[[X]]` / `%X%` / `~X~`	`spec.symbol_resolve`
Navegar / esboçar	`clause.list` · `clause.outline`
Comparar edições / histórico de commits	`spec.diff` · `spec.history`
Percorrer referências (entrada + saída)	`spec.crossrefs`
Ler tabelas estruturadas	`spec.tables`
Inspecionar a gramática	`spec.grammar` · `spec.sdo_index`
Enumerar intrínsecos bem conhecidos	`spec.well_known_intrinsics`
Encontrar testes de conformidade	`test262.search` · `test262.get`
Consultar uma proposta	`proposal.list` · `proposal.get`

Referência completa (esquemas de entrada, tipos de saída, chamadas de exemplo por ferramenta): docs/tools.md — gerada automaticamente a partir dos esquemas, então nunca fica desatualizada.

Especificações + edições

Toda ferramenta de leitura de especificação aceita spec ("262" ou "402", padrão "262") e edition (padrão "latest").

ECMA-262: es2016 – es2026, main. (ES5 / ES5.1 / ES6 não têm tags upstream e não são suportados.)
ECMA-402: es2016 – es2026, main. (402 publica cada edição anual como um branch esYYYY em vez de uma tag; a etapa de busca resolve um branch ou uma tag da mesma forma.)
Aliases: latest é ciente da especificação (cada especificação → sua versão estável atual, es2026 hoje). draft / next → main em ambos.

Tabela completa + como adicionar novos lançamentos: docs/editions.md.

Auto-hospedagem de snapshots

O servidor stdio busca snapshots do Worker hospedado público em https://mcp.xyzzylabs.ai/tc39/r2/<key> (cache → Worker → fallback empacotado), então em uma rede de egresso restrito ele cai para as edições empacotadas e não consegue alcançar as outras. Substitua a URL base via TC39_MCP_BASE_URL para apontar para um espelho privado — útil para redes de egresso restrito, ambientes isolados (air-gapped) ou execução contra um Worker auto-hospedado:

TC39_MCP_BASE_URL=https://my-mirror.example.com npx tc39-mcp

O endpoint só precisa servir a mesma estrutura de chaves (spec-<spec>-<edition>.json, test262-index.json, proposals-index.json) — um servidor de arquivos estático simples funciona. Se ele retornar ETags, o servidor revalida com If-None-Match (304s baratos); sem eles, ele apenas rebusca o objeto completo quando uma cópia em cache fica obsoleta. Para popular um espelho, execute npm run parse contra um checkout local (veja abaixo) e envie build/*.json para o bucket de sua escolha.

O cache fica em $XDG_CACHE_HOME/tc39-mcp (ou ~/.cache/tc39-mcp quando XDG_CACHE_HOME não está definido).

Compilar a partir do código-fonte (contribuidores)

Usuários finais não precisam disso — o pacote npm e o Worker hospedado são as superfícies suportadas acima. Isso é para trabalhar no próprio servidor.

git clone https://github.com/xyzzylabs/tc39-mcp
cd tc39-mcp
npm install
npm run fetch-spec               # ~2 min, ~150 MB — both specs at every supported edition
npm run parse                    # spec.html → build/spec-<spec>-<edition>.json
npm run fetch-test262            # optional, enables test262.* (~300 MB)
npm run build-test262-index
npm run fetch-proposals          # optional, enables proposal.* (~50 MB)
npm run build-proposals-index
npm run mcp                      # start the stdio MCP server against your source

Aponte seu cliente MCP para seu código-fonte local em vez do binário publicado:

{
  "mcpServers": {
    "tc39": {
      "type": "stdio",
      "command": "npm",
      "args": ["run", "--silent", "mcp"],
      "cwd": "/abs/path/to/tc39-mcp"
    }
  }
}

--silent mantém o banner de ciclo de vida do npm fora do stdout, para que o cliente MCP receba um fluxo JSON-RPC limpo.

Docs

Hospedados em mcp.xyzzylabs.ai/tc39 — pesquisáveis, com modo escuro, reconstruídos automaticamente a cada atualização, então /snapshots sempre reflete os SHAs ao vivo.

No repositório (também navegáveis no GitHub):

docs/getting-started.md — instalação → conexão → primeira chamada → verificação. Cinco minutos.
docs/tools.md — toda ferramenta, todo campo, todo exemplo. Gerado automaticamente a partir do código-fonte.
docs/cookbook.md — receitas multi-ferramenta: consultas entre especificações, rastreamento de deriva de prosa, referências cruzadas de gramática/SDO, cobertura test262, mapeamento proposta-para-cláusula.
docs/editions.md — edições suportadas + resolução de aliases.
docs/architecture.md — pipeline de dados, parser, cache, modelo de memória.
docs/deployment.md — stdio local, CLI npm, Cloudflare Worker hospedado, modelo de atualização, observabilidade.
CONTRIBUTING.md — que tipos de mudanças são fáceis de implementar, o que não será.
SECURITY.md — modelo de ameaças + divulgação responsável.
CHANGELOG.md — histórico de versões + convenção de atualização automática.

Política de Privacidade

tc39-mcp é um serviço de consulta de especificações somente leitura. O transporte stdio (npx tc39-mcp) não envia telemetria e nunca transmite suas consultas — snapshots são buscados do Worker hospedado em um cache frio ou obsoleto e servidos do disco local caso contrário; essas buscas carregam chaves de objetos R2, nunca ids de cláusulas ou argumentos de ferramentas. O Cloudflare Worker hospedado coleta apenas metadados padrão de requisição (IP para limitação de taxa, timestamps, cabeçalhos de requisição); ele não registra corpos de requisição, define cookies ou compartilha dados com terceiros.

Política completa: mcp.xyzzylabs.ai/tc39/privacy

Para perguntas sobre privacidade, abra uma issue com o rótulo privacy no GitHub.

Licença

MIT