@mosaicoo/svg-engine 0.1.0

package/types/mosaicoo-svg-engine-ai-nlu.d.ts

@@ -0,0 +1,1834 @@
+import * as i0 from '@angular/core';
+import { Injector, Signal, InjectionToken, Provider } from '@angular/core';
+import { Disposable, NodeId } from '@mosaicoo/svg-engine/core';
+import { MenuContributionRegistry, MenuContribution, EditorPlugin } from '@mosaicoo/svg-engine/edit';
+
+/**
+ * **NLU (Natural Language Understanding) types — D-046 Fase 1**
+ *
+ * Rule-based natural-language → command pipeline. Zero ML, zero
+ * external download — pure regex + dictionary + Levenshtein fuzzy
+ * matching. Cobre ~70–80% dos comandos comuns ("undo", "delete",
+ * "criar retângulo vermelho"). Fase 2 (ML classifier) e Fase 3 (SLM)
+ * são entry points separados que reúsam esse mesmo contrato.
+ *
+ * **Entry point separado `svg-engine/ai/nlu`** (não dentro de `edit`)
+ * pra que a camada AI fique 100% desacoplada — Modo 1 (headless puro
+ * D-037) não importa nada de `ai/` quando não usar. Fase 2 e 3
+ * (Transformers.js / WebLLM) entram em `svg-engine/ai/nlu-ml` e
+ * `svg-engine/ai/nlu-slm`, ambos reaproveitando o contrato
+ * {@link NluIntent} / {@link NaturalLanguageService} definido aqui.
+ *
+ * **Por que mirrors `MenuContributionContext`**: o NLU é uma surface
+ * a mais (`<svge-menu-bar>`, `<svge-toolbar>`, `<svge-context-menu>`
+ * + agora command palette por voz/texto). Mantém-se o mesmo
+ * contrato multi-editor scope (D-042/D-043): `injector` na ctx,
+ * services resolvidos lazy do scope ativo.
+ */
+/**
+ * Per-fire context passed to {@link NluIntent.execute} (and to the
+ * NLU service `parse` / `execute` entry points). Espelho exato do
+ * {@link MenuContributionContext} pra que handlers reaproveitem a
+ * mesma resolução de scope ativo (per-editor no D-042).
+ */
+interface NluContext {
+    /**
+     * Injector do consumer (UI component que disparou o parse — command
+     * palette, voice input, etc). Em apps route-scoped, é o injector
+     * do editor ativo; em single-editor é equivalente ao root.
+     */
+    readonly injector: Injector;
+}
+/**
+ * Tipo declarativo de slot que um intent pode extrair do input.
+ *
+ * **Variantes**:
+ * - `number`: número decimal/inteiro (com unidade opcional como `px`).
+ * - `color`: nome de cor (PT/EN via dicionário) OU hex `#rrggbb` /
+ *   `rgb()` / `hsl()`, com suporte a **intensificadores adjacentes**
+ *   ("azul claro", "verde bem escuro") via `parseColorPhrase`.
+ * - `shape`: nome de forma (PT/EN via `SHAPE_DICTIONARY`) — resolve
+ *   automaticamente "círculo"→`circle`, "retângulo"→`rect`,
+ *   "balão"→`group`, etc. **Use este em vez de `enum` quando o
+ *   slot for forma SVG** — `enum` exige match exato do canonical
+ *   ('rect'), não suporta vocabulário PT/EN nem aliases semânticos.
+ * - `enum`: valor de uma lista fechada (lookup case-insensitive,
+ *   com fuzzy match dist ≤ 1). Use para domínios fechados sem
+ *   vocabulário multilíngue (e.g., 'landscape'/'portrait').
+ * - `string`: token livre — usado raramente, intent precisa ser
+ *   tolerante a ruído.
+ *
+ * **`optional`**: quando `false` (default), confidence cai abaixo do
+ * threshold se o slot não for preenchido. Quando `true`, o slot é
+ * preenchido com `default` (ou `undefined`) e confidence mantém.
+ */
+type NluSlotSchema = {
+    readonly kind: 'number';
+    readonly optional?: boolean;
+    readonly default?: number;
+    readonly anchorKeywords?: readonly string[];
+    /**
+     * Quando `false`, o slot **não** é preenchido pelo pass posicional
+     * genérico — só por pre-passes específicos (ex.: `count` da
+     * repetição, extraído como "número antes de uma forma"). Evita que
+     * um número de dimensão seja capturado como contagem por engano.
+     * Default `true` (positional).
+     */
+    readonly positional?: boolean;
+} | {
+    readonly kind: 'color';
+    readonly optional?: boolean;
+    readonly default?: string;
+    readonly anchorKeywords?: readonly string[];
+} | {
+    readonly kind: 'shape';
+    readonly optional?: boolean;
+    readonly default?: string;
+    readonly anchorKeywords?: readonly string[];
+} | {
+    readonly kind: 'enum';
+    readonly values: readonly string[];
+    readonly optional?: boolean;
+    readonly default?: string;
+    readonly anchorKeywords?: readonly string[];
+    /**
+     * Quando `false`, o match do enum é **exato** (apenas
+     * `values.includes(token)`), sem fuzzy Levenshtein. Use para
+     * vocabulários curtos em que o fuzzy geraria falso-positivo
+     * (ex.: layout `'grade'` casaria `'grande'` por distância 1).
+     * Default `true` (fuzzy ligado).
+     */
+    readonly fuzzy?: boolean;
+} | {
+    readonly kind: 'string';
+    readonly optional?: boolean;
+    readonly default?: string;
+    readonly anchorKeywords?: readonly string[];
+} | {
+    /**
+     * **`point`** — extrai par `{ x, y }` de **dois números adjacentes**
+     * (ex: "100 50" ou "100x50"). Combinar com `anchorKeywords`
+     * (`['posicao','position','em','at']`) pra desambiguar de outros
+     * slots numéricos no mesmo intent.
+     */
+    readonly kind: 'point';
+    readonly optional?: boolean;
+    readonly default?: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly anchorKeywords?: readonly string[];
+} | {
+    /**
+     * **`gradient`** — preenchimento por gradiente. Extraído **só** por
+     * um pre-pass dedicado e **só quando a palavra-chave** ("gradiente"/
+     * "degradê"/"degrade"/"gradient") aparece — assim cores sólidas
+     * ("amarelo", "vermelho") seguem 100% intactas. O valor extraído é
+     * `{ kind: 'linear'|'radial', direction: 'horizontal'|'vertical'|
+     * 'diagonal', colors: string[] }`: o handler deriva os stops (1 cor
+     * → clara→escura; N cores → distribuídas) e a geometria. Nunca é
+     * posicional (não compete com o slot `fill`).
+     */
+    readonly kind: 'gradient';
+    readonly optional?: boolean;
+    /** Não usado (gradient é só pre-pass) — presente p/ uniformidade do union. */
+    readonly anchorKeywords?: readonly string[];
+};
+/**
+ * **`anchorKeywords`** — palavras que precedem o valor do slot no
+ * input ("**borda** azul" → slot `stroke=azul`; "**posição** 100 50"
+ * → slot `position={x:100,y:50}`).
+ *
+ * Como funciona:
+ * 1. Extractor faz primeiro um **pass anchored**: pra cada slot com
+ *    `anchorKeywords`, procura o anchor token (exato ou fuzzy ≤1) e
+ *    consome o(s) próximo(s) token(s) compatível(eis) com o `kind`.
+ * 2. Depois faz o pass **posicional** normal pros slots sem anchor.
+ * 3. Tokens já consumidos no anchored pass ficam de fora do posicional
+ *    — evita dupla atribuição.
+ *
+ * Útil quando o mesmo intent tem múltiplos slots de mesmo `kind`
+ * (e.g., `create-shape` com `fill` + `stroke` ambos `kind: 'color'`):
+ * sem âncora, o extractor pega a primeira cor pra `fill` e ignora a
+ * segunda. Com âncora `'borda'/'contorno'/'stroke'`, "fill vermelho
+ * borda azul" produz `{fill:'red', stroke:'blue'}` corretamente.
+ */
+/**
+ * Definição de um intent registrável no {@link NaturalLanguageService}.
+ *
+ * **Filosofia**:
+ * - `keywords`: palavras-chave **disparadoras** (PT/EN). Match exato
+ *   (após tokenize/deacento) vira anchor da intent — se nenhuma
+ *   keyword aparecer (mesmo aproximada via Levenshtein), o intent
+ *   nem é considerado candidato.
+ * - `slots`: opcionais; cada um declara `kind` (number/color/enum/string)
+ *   e se é `optional`. Extractor preenche o que conseguir.
+ * - `execute`: handler que recebe slots já extraídos + ctx. MUST NOT
+ *   throw — falhas devem ser logged + ignored (assim como
+ *   `MenuContribution.run`).
+ *
+ * **Multi-editor (D-042/D-043)**: `execute` recebe `NluContext` e
+ * deve resolver services do `ctx.injector` — não capturar root
+ * services em closures.
+ *
+ * **Exemplo**:
+ * ```ts
+ * nlu.registerIntent({
+ *   id: 'create-rect',
+ *   keywords: ['rectangle', 'rect', 'retângulo', 'retangulo'],
+ *   actionKeywords: ['create', 'add', 'criar', 'desenhar'],
+ *   slots: {
+ *     fill: { kind: 'color', optional: true },
+ *     width: { kind: 'number', optional: true, default: 100 },
+ *     height: { kind: 'number', optional: true, default: 100 },
+ *   },
+ *   execute(slots, ctx) {
+ *     const bus = ctx.injector.get(CommandBus);
+ *     bus.dispatch(new InsertNodeCommand(rootId, createRect({...}, {style: {fill: slots.fill}})));
+ *   },
+ * });
+ * ```
+ */
+interface NluIntent {
+    /** Stable unique id. Reverse-DNS recommended (`svge.builtin.nlu.create-rect`). */
+    readonly id: string;
+    /**
+     * Palavras-chave **primárias** que identificam o intent (substantivos,
+     * objetos: "rectangle", "retângulo", "circle", "círculo", "selection").
+     * Pelo menos uma deve aparecer (exato ou fuzzy ≤ 2 dist) pra intent
+     * ser candidato. Comparação após `tokenize` (lowercase + deacento).
+     */
+    readonly keywords: readonly string[];
+    /**
+     * **`requiredAllGroups`** (D-046 review-7) — strict-AND matching:
+     * cada **grupo** representa um elemento semântico do intent que
+     * DEVE estar presente no input (pelo menos uma palavra do grupo
+     * casa, exato ou fuzzy). Diferente de `keywords` (OR fraco),
+     * requiredAllGroups exige TODOS os grupos preenchidos.
+     *
+     * **Caso de uso típico**: intents auto-descobertos de menu items
+     * multi-token como "Select All" precisam garantir que TANTO o
+     * verbo (select / selecionar / selecione) QUANTO o qualificador
+     * (all / tudo / todos) apareçam — senão "selecione estrela"
+     * matcharia "Select All" e selecionaria tudo erradamente.
+     *
+     * **Estrutura**: array de grupos; cada grupo é array de variantes
+     * sinônimas pra uma posição semântica. Exemplo "Select All":
+     * ```
+     * requiredAllGroups: [
+     *   ['select', 'selecionar', 'selecione', 'marcar', ...],  // verbo
+     *   ['all', 'tudo', 'todos', 'todas', 'everything'],        // qualificador
+     * ]
+     * ```
+     *
+     * Quando `requiredAllGroups` é declarado, o `keywords` ainda é
+     * usado pra ranking de confidence mas o **gate** de candidato vira
+     * o requiredAllGroups (todos satisfeitos OR keywords match com ≥1
+     * candidato — política pragmática).
+     */
+    readonly requiredAllGroups?: readonly (readonly string[])[];
+    /**
+     * Verbos / ações associadas (opcional): "create", "criar", "add",
+     * "desenhar", "delete", "deletar". Quando presente, eleva confidence
+     * mas não é obrigatório — alguns intents são triggados só pelo
+     * substantivo ("rectangle" sozinho pode criar um). Útil pra
+     * desambiguar intents que compartilham keywords (e.g.,
+     * "delete circle" vs "create circle").
+     */
+    readonly actionKeywords?: readonly string[];
+    /** Schema dos slots extraíveis (por nome). */
+    readonly slots?: Record<string, NluSlotSchema>;
+    /**
+     * Marca o intent como **destrutivo** — UI deve pedir confirmação
+     * antes de executar (mesmo confidence alta). Ex: delete, clear,
+     * reset all. Default `false`.
+     */
+    readonly destructive?: boolean;
+    /** Hint humano pra UI exibir como sugestão / autocomplete. */
+    readonly description?: string;
+    /** Handler executado quando o intent é o top candidate + acima do threshold. */
+    execute(slots: Record<string, unknown>, ctx: NluContext): void | Promise<void>;
+}
+/**
+ * Resultado de {@link NaturalLanguageService.parse} — um candidato
+ * que casou com o input, com confidence + slots extraídos. Ordenado
+ * por confidence desc.
+ */
+interface NluCandidate {
+    /** Intent que casou. */
+    readonly intent: NluIntent;
+    /**
+     * Confidence em `[0, 1]`.
+     * - `≥ 0.7`: executa direto.
+     * - `0.4–0.7`: pede confirmação (UI decide via threshold configurável).
+     * - `< 0.4`: rejeita (parse retorna candidate mesmo assim — UI usa
+     *   pra sugerir alternativas).
+     */
+    readonly confidence: number;
+    /** Slots extraídos do input (preenche `default` quando ausente). */
+    readonly slots: Record<string, unknown>;
+    /**
+     * Razões que levaram ao score — útil pra debug + UI explicar
+     * "achei isso porque casou 'criar' (exato) e 'retângulo' (fuzzy)".
+     */
+    readonly matches: readonly NluMatchReason[];
+}
+/** Detalhe de um match individual contribuindo pro confidence. */
+interface NluMatchReason {
+    /** O que casou: keyword, actionKeyword, ou slot. */
+    readonly kind: 'keyword' | 'action' | 'slot';
+    /** O termo da intent que foi matched. */
+    readonly term: string;
+    /** O token do input que casou (após tokenize). */
+    readonly token: string;
+    /** Distância de Levenshtein (0 = exato). */
+    readonly distance: number;
+    /**
+     * Índice do token no array de input (D-046 review-10).
+     *
+     * Quando `kind === 'slot'`, é `-1` (slot value não é necessariamente
+     * um único token — pode ter sido extraído de uma frase de cor ou
+     * `kind: 'point'` compondo 2 números).
+     *
+     * Para `kind: 'keyword'` ou `'action'`, é o índice exato do token
+     * que casou. Usado pelo extractor pra marcar consumed e evitar
+     * dupla atribuição (resolve bug de `tokens.indexOf(value)` retornando
+     * sempre 1ª ocorrência em inputs com tokens repetidos).
+     */
+    readonly tokenIndex?: number;
+}
+/**
+ * Threshold semântico do parse. UI consumers podem customizar via
+ * `parse(text, ctx, { threshold: 0.5 })`.
+ */
+interface NluParseOptions {
+    /** Mínimo confidence pra candidate ser retornado. Default `0.3`. */
+    readonly threshold?: number;
+    /** Máximo de candidates retornados (ordenados por confidence). Default `5`. */
+    readonly maxResults?: number;
+}
+/**
+ * Threshold semântico do execute. UI consumers podem customizar.
+ */
+interface NluExecuteOptions extends NluParseOptions {
+    /**
+     * Confidence mínima pra dispatchar direto. Default `0.7`.
+     * Abaixo disso, o `confirmGate` decide.
+     */
+    readonly autoExecuteThreshold?: number;
+    /**
+     * Hook opcional pra confirmação interativa (e.g., mostrar dialog
+     * com "Você quis dizer: criar retângulo?"). Recebe o top candidate
+     * e retorna se deve executar.
+     *
+     * **Default**: `null` — sem confirmação, executa qualquer
+     * candidate ≥ `autoExecuteThreshold`, rejeita os abaixo.
+     *
+     * **Destrutivos**: quando `intent.destructive === true`,
+     * `confirmGate` é **obrigatório** — sem ele, intents destrutivos
+     * são sempre rejeitados (defesa contra dispatch acidental de
+     * delete/clear via fuzzy match ruim).
+     */
+    readonly confirmGate?: ((candidate: NluCandidate) => boolean | Promise<boolean>) | null;
+}
+/**
+ * Resultado final de {@link NaturalLanguageService.execute}.
+ */
+interface NluExecuteResult {
+    /** `true` se um candidate foi executado, `false` se rejeitado / abaixo do threshold / sem match. */
+    readonly executed: boolean;
+    /** O candidate executado (ou top candidate quando `executed === false`, pra UI exibir alternativas). */
+    readonly candidate: NluCandidate | null;
+    /**
+     * Lista de candidates considerados (top N por confidence). Útil
+     * pra UI mostrar "também achei: ...".
+     */
+    readonly alternatives: readonly NluCandidate[];
+    /** Por que não executou (`null` quando `executed === true`). */
+    readonly rejection: 'no-match' | 'below-threshold' | 'confirmation-declined' | 'destructive-no-gate' | 'execute-error' | null;
+    /**
+     * Erro capturado quando `rejection === 'execute-error'` (D-046
+     * review-10 / M4). Service envolve `intent.execute()` em try/catch
+     * — handler que lança não derruba a UI nem deixa Promise pendurada.
+     */
+    readonly error?: Error;
+}
+
+/**
+ * **`NaturalLanguageService`** — D-046 Fase 1 (rule-based NLU).
+ *
+ * Singleton root-provided que registra {@link NluIntent}s e
+ * traduz texto livre em comandos dispatcháveis. Composição direta
+ * dos parsers (`tokenize` → `fuzzyMatch` → `extractSlots`) com
+ * scoring de confidence.
+ *
+ * **Algoritmo de `parse(text)`**:
+ *
+ * 1. **Tokenize**: lowercase + deacento + split (preserva números/hex).
+ * 2. **Para cada intent registrado**, calcula `score`:
+ *    a. **Keywords**: fuzzy match com adaptive distance. Se nenhuma
+ *       keyword bate (nem aproximada), pula a intent. Score base do
+ *       melhor match.
+ *    b. **Action keywords** (opcional): match contra `actionKeywords`
+ *       da intent + lookup canonical no `ACTION_DICTIONARY`. Eleva
+ *       score quando casa.
+ *    c. **Slots**: extrai com `extractSlots`. Slots obrigatórios não
+ *       preenchidos penalizam (subtrai 0.15 cada). Slots opcionais
+ *       preenchidos elevam levemente (0.05 cada).
+ *    d. **Penalidade por distância**: cada match fuzzy não-exato
+ *       reduz o score proporcionalmente.
+ * 3. **Sort + filter** por threshold + cap em `maxResults`.
+ *
+ * **`execute(text)`**: parse + auto-execute se ≥ `autoExecuteThreshold`
+ * (default 0.7), respeitando `confirmGate` pra destrutivos.
+ *
+ * **Multi-editor (D-042/D-043)**: o `NluContext` recebido pelos
+ * handlers tem `injector` do consumer — services devem ser resolvidos
+ * dele, nunca cacheados em closure.
+ *
+ * **Por que `Injectable({ providedIn: 'root' })`**: o registry de
+ * intents é global (todos os editors compartilham a definição), mas
+ * a EXECUÇÃO é per-scope via `NluContext.injector`. Mesmo padrão
+ * que `MenuContributionRegistry`.
+ */
+declare class NaturalLanguageService {
+    private readonly _intents;
+    /** Snapshot reativo dos intents registrados (insertion order). */
+    readonly intents: Signal<readonly NluIntent[]>;
+    /**
+     * **D-046 review-10 (L12)**: counter conveniente — consumers que só
+     * precisam do número (e.g., status bar "26 intents disponíveis")
+     * subscrevem aqui em vez do array inteiro (evita re-render quando
+     * o array muda mas length não).
+     */
+    readonly intentsCount: Signal<number>;
+    /**
+     * **Cache de description tokens por intent** — usado pelo
+     * description-matching pass (meio-termo "semantic disambiguator"
+     * SEM ML deps). Computado lazy quando o intent aparece pela 1ª vez
+     * num scoring run; invalidado quando o intent é desregistrado.
+     *
+     * **Por que cache**: tokenize + filter stopwords é ~10ms por
+     * description, e o parse roda em cada keystroke do usuário —
+     * computar 30+ intents toda vez ficaria perceptível.
+     */
+    private readonly descriptionTokensCache;
+    /**
+     * Registra um intent novo. Retorna `Disposable` pra remover (em geral
+     * trackeada pelo plugin via `ctx.track()` igual aos outros registries).
+     *
+     * **Erros**:
+     * - Throw em `id` vazio
+     * - Throw em `id` duplicado
+     * - Throw em `keywords` vazio (intent sem keyword nunca seria matched)
+     */
+    registerIntent(intent: NluIntent): Disposable;
+    /**
+     * Tokeniza + filtra description do intent e armazena no cache.
+     * No-op se o intent não tem description ou já está cached.
+     */
+    private populateDescriptionCache;
+    /**
+     * **Description-matching boost** (meio-termo "semantic disambiguator"
+     * sem ML deps).
+     *
+     * Tokeniza a `description` do intent (sem stopwords) e conta hits
+     * vs tokens do input. Cada hit adiciona +0.04 (cap 0.2 total). Não
+     * substitui keyword matching — só complementa quando há candidatos
+     * com score próximo (e.g., dois intents com keyword exata, ambos
+     * 0.65; o de description mais alinhada vence).
+     *
+     * **Cache**: tokens da description são computados na 1ª chamada
+     * e guardados em `descriptionTokensCache` keyed por `intent.id`.
+     *
+     * **Quando contribui**: SEMPRE — score é monotônico. UI consumers
+     * que queiram desligar podem passar `options.disableDescriptionBoost`
+     * (não implementado ainda — Fase 2 quando ML chegar e a heurística
+     * for mais relevante).
+     */
+    private descriptionBoost;
+    /** Procura intent por id (`null` se ausente). */
+    getIntent(id: string): NluIntent | null;
+    /**
+     * Parse `text` em candidates ordenados por confidence desc.
+     *
+     * @param text input natural do usuário
+     * @param _ctx NluContext (não usado no parse — só no execute; aqui
+     *   mantido por simetria de API)
+     * @param options threshold + maxResults
+     */
+    parse(text: string, _ctx: NluContext, options?: NluParseOptions): readonly NluCandidate[];
+    /**
+     * Parse + dispatch o top candidate.
+     *
+     * **Política**:
+     * - `intent.destructive === true` SEM `confirmGate` → rejeita
+     *   (defesa contra delete acidental).
+     * - `confidence ≥ autoExecuteThreshold` (default 0.7) → executa direto
+     *   (ou via confirmGate quando destrutivo).
+     * - `confidence < autoExecuteThreshold` E `confirmGate` presente →
+     *   chama o gate; só executa se retornar `true`.
+     * - Senão → rejeita com `'below-threshold'`.
+     */
+    execute(text: string, ctx: NluContext, options?: NluExecuteOptions): Promise<NluExecuteResult>;
+    /**
+     * Conectores que separam comandos numa frase composta
+     * ("crie X, e um Y"). Split em `,`/`;` + " e "/" depois "/" também ".
+     */
+    private static readonly CLAUSE_SPLIT_RE;
+    /**
+     * Verbos de comando (criação/edição) que marcam uma cláusula como
+     * comando autônomo. Deaccentuados/lowercase (forma que o tokenizer gera).
+     */
+    private static readonly COMMAND_VERBS;
+    /**
+     * **Multi-comando por frase** — divide o texto nos conectores e executa
+     * cada cláusula como um comando independente. Cada `execute()` despacha
+     * seu próprio command no bus, então **cada forma é um passo de undo
+     * separado**.
+     *
+     * **Sem regressão**: quando não há split real (frase simples, ou os
+     * "pedaços" são apenas fragmentos — listas de cor "preto e branco",
+     * números "100 e 200"), recai EXATAMENTE no `execute(text)` de sempre.
+     *
+     * Heurística anti over-split: um pedaço só vira comando separado se
+     * contiver uma **forma** ou um **verbo de comando**; senão é re-fundido
+     * ao anterior.
+     *
+     * @returns um {@link NluExecuteResult} por comando, na ordem da frase.
+     */
+    executeSequence(text: string, ctx: NluContext, options?: NluExecuteOptions): Promise<readonly NluExecuteResult[]>;
+    /**
+     * Divide `text` em cláusulas-comando. Pedaços que não parecem comando
+     * (sem forma nem verbo) são re-fundidos ao anterior. Retorna ≤1 item
+     * quando não há split real.
+     */
+    private splitIntoClauses;
+    /** `true` se a cláusula contém uma forma ou um verbo de comando. */
+    private clauseLooksLikeCommand;
+    /**
+     * Executa um candidate **específico** (escolhido pelo usuário via UI
+     * — e.g., clique numa alternativa) aplicando as mesmas regras de
+     * segurança do {@link execute}: destructive sem gate rejeita;
+     * confidence baixa sem gate rejeita.
+     *
+     * **Por que precisa de método separado**: chamar `candidate.intent.execute()`
+     * direto bypassa toda a lógica de threshold/destructive. UI components
+     * (`<svge-nlu-input>` alternatives list) DEVEM usar este método em
+     * vez de `intent.execute()` direto, pra preservar a defesa contra
+     * delete acidental.
+     *
+     * **Política idêntica ao `execute`**:
+     * - Destrutivo SEM `confirmGate` → rejeita `'destructive-no-gate'`.
+     * - Destrutivo COM gate → roda gate; só executa se aprovar.
+     * - Não-destrutivo com confidence ≥ `autoExecuteThreshold` → executa.
+     * - Não-destrutivo com confidence < threshold E gate presente →
+     *   roda gate.
+     * - Senão → `'below-threshold'`.
+     *
+     * @param candidate o NluCandidate a executar (vindo de `parse()`).
+     * @param ctx contexto (injector do consumer).
+     * @param options threshold + confirmGate.
+     */
+    executeCandidate(candidate: NluCandidate, ctx: NluContext, options?: NluExecuteOptions): Promise<NluExecuteResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalLanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalLanguageService>;
+}
+
+/**
+ * **`discoverMenuIntents`** — D-046 Fase 1.
+ *
+ * Auto-promove TODAS as contribuições do {@link MenuContributionRegistry}
+ * em intents NLU. Cada menu item vira um intent cujo handler executa
+ * o `run()` original com o `MenuContributionContext` derivado do
+ * `NluContext.injector`.
+ *
+ * **Como derivamos keywords a partir do `label`**: tokenize o label
+ * (lowercase + deacento), remove stopwords, mantém o resto. "Bring
+ * to Front" → `['bring', 'front']`; "Selecionar tudo" →
+ * `['selecionar', 'tudo']`. Plugins que queiram aliases adicionais
+ * podem registrar intents customizados via
+ * {@link NaturalLanguageService.registerIntent} sem conflito.
+ *
+ * **Skip de dividers + items sem label + roadmap**: `divider: true`,
+ * label vazio, ou `comingSoon: true` (D-085) não produzem intent — não
+ * são ações executáveis (o `run()` de um item roadmap é no-op).
+ *
+ * **Destrutivos**: items cujo label contém "delete"/"remove"/"clear"/
+ * "deletar"/"excluir"/"remover"/"apagar" são marcados `destructive: true`
+ * — a NLU exige `confirmGate` pra dispatch automático.
+ *
+ * **Multi-editor (D-042/D-043)**: o handler propaga `ctx.injector`
+ * para o `MenuContributionContext` esperado pelo `run()` do menu
+ * contribution. Cadeia de scope ativo preservada end-to-end.
+ *
+ * **Reactivity**: este helper é one-shot — registra os intents que
+ * EXISTEM no momento da chamada. Para auto-discovery contínuo
+ * (plugins instalados depois também viram intents),
+ * use {@link discoverMenuIntentsReactive} — wrapper baseado em
+ * `effect()` que reflete mudanças do registry em tempo real
+ * (Audit #12).
+ *
+ * **Retorno**: array de `Disposable` (um por intent registrado) +
+ * count. O `composedDispose` permite cleanup em massa via
+ * `ctx.track()`.
+ */
+interface DiscoverMenuIntentsResult {
+    /** Disposables dos intents criados — array vazio quando nada foi descoberto. */
+    readonly disposables: readonly Disposable[];
+    /** Quantos intents foram efetivamente criados. */
+    readonly count: number;
+    /** Disposable composto que dispara dispose() em todos. */
+    readonly composedDispose: Disposable;
+}
+/**
+ * Cria intent NLU a partir de uma `MenuContribution` específica.
+ * Retorna `null` quando a contribution não é elegível (divider, label
+ * vazio, ou tokens insuficientes pra match útil).
+ */
+declare function menuContributionToIntent(contrib: MenuContribution): NluIntent | null;
+/**
+ * Walks o registry, cria intents pra cada contribution elegível, e
+ * registra todos no service. Skip silencioso pra contribuições que
+ * gerariam intent duplicado (caller pode já ter registrado um
+ * customizado com o mesmo id) — não throws.
+ */
+declare function discoverMenuIntents(registry: MenuContributionRegistry, service: NaturalLanguageService): DiscoverMenuIntentsResult;
+/**
+ * **`discoverMenuIntentsReactive`** — Audit #12. Reactive companion to
+ * {@link discoverMenuIntents}.
+ *
+ * Performs an **immediate synchronous discovery** of all current menu
+ * contributions (so callers reading `service.intents()` right after
+ * this returns see the auto-discovered intents — same observable
+ * behavior as the one-shot helper at install time), AND registers an
+ * Angular `effect()` that re-runs discovery whenever
+ * `registry.contributions()` emits — covering plugins installed AFTER
+ * the NLU plugin and contributions disposed at any later time.
+ *
+ * **Strategy on each change**: tear down the previous batch via its
+ * `composedDispose`, then rebuild a fresh batch from the new registry
+ * snapshot. Coarse-grained but correct: no diff/merge bookkeeping
+ * means no chance of half-state on race conditions, at the cost of
+ * O(N) work per registry mutation (N is small for menu items, usually
+ * ≤ 50). Custom intents the consumer registered out-of-band stay
+ * untouched because `discoverMenuIntents` skips ids already present.
+ *
+ * **Why an effect, not a manual subscription**: Angular signals don't
+ * expose a `subscribe()` — `effect()` IS the official subscription
+ * mechanism. It also gets disposed cleanly via `effectRef.destroy()`,
+ * letting the returned `Disposable` cover both the effect AND the
+ * current batch of intents.
+ *
+ * **Injection context requirement**: `effect()` may only be created
+ * inside an injection context. We accept an explicit `Injector` and
+ * use `runInInjectionContext` so the function works from anywhere —
+ * including plugin `install(ctx)` blocks that aren't injection
+ * contexts themselves.
+ *
+ * **Echo skipping via reference identity**: Angular schedules the
+ * effect's first run for a later microtask, NOT immediately at
+ * creation. That first run might happen BEFORE or AFTER unrelated
+ * signal mutations. Using a "skip first" flag is unreliable. Instead
+ * we capture the exact array reference that the initial sync
+ * discovery consumed and short-circuit any firing where the signal
+ * still returns that same reference — guaranteed safe because
+ * `MenuContributionRegistry.register` and the returned dispose both
+ * produce a NEW array (immutable update), so identity comparison
+ * cleanly distinguishes "no real change" from "actual mutation".
+ */
+interface DiscoverMenuIntentsReactiveResult {
+    /**
+     * Composite disposable — stops the effect AND tears down the
+     * currently-tracked batch of intents. Idempotent: calling
+     * `dispose()` twice is a silent no-op.
+     */
+    readonly disposable: Disposable;
+}
+declare function discoverMenuIntentsReactive(registry: MenuContributionRegistry, service: NaturalLanguageService, injector: Injector): DiscoverMenuIntentsReactiveResult;
+
+declare const builtinNluPlugin: EditorPlugin;
+
+/**
+ * Tokenizer multilíngue (PT + EN) — D-046 Fase 1.
+ *
+ * Operações em ordem:
+ * 1. Lowercase
+ * 2. **Deacentuação** via `String.prototype.normalize('NFD')` + strip
+ *    de marks combining — "vermelho" → "vermelho", "círculo" →
+ *    "circulo", "ação" → "acao". Permite o dicionário ser keyed em
+ *    ASCII puro e ainda casar com input acentuado.
+ * 3. Split por whitespace + pontuação comum, **preservando**:
+ *    - números (incluindo decimais `1.5`, `2,5` — pt/en)
+ *    - dimensões compostas `100x50`
+ *    - hex colors `#ff0000`
+ * 4. Filter de tokens vazios.
+ *
+ * **Não filtra stopwords aqui** — algumas etapas (slot-extractor)
+ * precisam dos tokens originais pra ordem posicional. Caller decide
+ * quando aplicar `isStopword`.
+ *
+ * **Por que não usar Intl.Segmenter / NLP libs**: zero-deps é
+ * requisito explícito da Fase 1 (D-046). Tokenização "ingênua"
+ * cobre o vocabulário de comandos de editor de SVG sem ruído.
+ */
+/**
+ * Normaliza um texto removendo acentos via NFD + strip de marks
+ * combining (Unicode category `Mn`).
+ *
+ * **Por que NFD**: separa o caractere base da marca combinante
+ * (`á` → `a` + ` ́ `), depois removemos só as marcas. Funciona pra PT
+ * (acentos agudos, til, cedilha) e qualquer alfabeto latino estendido.
+ *
+ * **Edge case** mantido: caracteres sem decomposição NFD passam
+ * intactos (preserva tokens em outros alfabetos se aparecerem).
+ */
+declare function deaccent(input: string): string;
+/**
+ * Normaliza texto: lowercase + deacentuação. Não tokeniza — só
+ * normaliza pra usar em dicionários, comparações.
+ */
+declare function normalize(input: string): string;
+/**
+ * Tokeniza um input textual seguindo a pipeline descrita no header.
+ *
+ * **Algoritmo (single-pass scanner)**:
+ * 1. Itera caractere por caractere.
+ * 2. Caractere de pontuação (`PUNCT_CHARS`) OU `,`/`.` que NÃO está
+ *    entre dígitos → fecha o token corrente.
+ * 3. Caractere "normal" (incluindo `,` / `.` entre dígitos) → acumula.
+ * 4. Fim do input → fecha o último token se houver.
+ *
+ * **Retorno**: array de tokens normalizados (lowercase, sem acento),
+ * sem vazios, preservando ordem de aparição (importante pro
+ * slot-extractor encontrar "vermelho" depois de "fill").
+ *
+ * **Custo**: O(n) no tamanho do input.
+ */
+declare function tokenize(input: string): readonly string[];
+/**
+ * Tokeniza E remove stopwords. Atalho conveniente; quando você
+ * precisa preservar a ordem original (slot extraction posicional),
+ * use `tokenize()` direto.
+ */
+declare function tokenizeWithoutStopwords(input: string, stopwords: ReadonlySet<string>): readonly string[];
+
+/**
+ * Distância de Levenshtein — edit distance clássica (insertion,
+ * deletion, substitution; cada uma custa 1). Usada pelo fuzzy
+ * matcher pra encontrar a palavra mais próxima no dicionário quando
+ * o usuário digita errado ("vermelo" → "vermelho", dist 1;
+ * "retangulo" → "retangulo", dist 0).
+ *
+ * **Implementação**: 2-row DP (memória O(min(m,n))), curto-circuita
+ * cedo via "early termination on max distance" — útil porque o
+ * matcher fuzzy só aceita distâncias pequenas (≤ 2 default) e abandonar
+ * cedo evita varrer a tabela inteira pra strings totalmente diferentes.
+ *
+ * **Sem cache**: as strings são curtas (tokens de palavras, ≤ 20
+ * chars) e o overhead de hashmap supera o custo de recomputar. Se
+ * benchmarks futuros mostrarem hot spot, adicionar cache LRU
+ * Map<`${a}|${b}`, number> com cap pequeno.
+ *
+ * **Zero deps** (requisito Fase 1 D-046).
+ */
+/**
+ * Calcula a distância de Levenshtein entre `a` e `b`.
+ *
+ * @param a primeira string (lowercase + deacentuada já preferível)
+ * @param b segunda string
+ * @param maxDist se informado, retorna `Infinity` assim que prova
+ *                que a distância real excede `maxDist` (early
+ *                termination, ~10× speedup em mismatches grandes).
+ * @returns distância em [0, max(a.length, b.length)] ou `Infinity`
+ *          se `maxDist` foi excedida.
+ */
+declare function levenshtein(a: string, b: string, maxDist?: number): number;
+/**
+ * Encontra o melhor match em `candidates` pra `query`, retornando
+ * a string + distância. Curto-circuita em match exato.
+ *
+ * @param query termo a buscar (normalizado)
+ * @param candidates lista de strings candidatas (normalizadas)
+ * @param maxDist distância máxima aceitável; ignora candidates além disso
+ * @returns `{ match, distance }` ou `null` se nenhum candidate dentro do limite
+ */
+declare function bestMatch(query: string, candidates: readonly string[], maxDist: number): {
+    match: string;
+    distance: number;
+} | null;
+
+/**
+ * Resultado de um match fuzzy entre um token de input e um termo
+ * de dicionário/keyword.
+ */
+interface FuzzyMatch {
+    /** Termo do dicionário que casou. */
+    readonly term: string;
+    /** Token do input (preservado pra `NluMatchReason`). */
+    readonly token: string;
+    /** Distância de Levenshtein (0 = exato). */
+    readonly distance: number;
+    /**
+     * Confidence sub-1 derivada da distância vs comprimento do termo.
+     * Match exato = 1.0; match com 1 erro em palavra de 8 letras ~0.875.
+     * Match com 2 erros em palavra de 4 letras = 0.5.
+     */
+    readonly score: number;
+    /**
+     * **`tokenIndex`** (D-046 review-10): índice do token original no
+     * array de entrada. Sempre populado por {@link fuzzyMatchAny} e
+     * {@link fuzzyMatchAll}; em {@link fuzzyMatchToken} fica `-1` porque
+     * o caller não passa array (e sabe o índice por contexto próprio).
+     *
+     * **Motivação**: `NaturalLanguageService` precisa marcar o ÍNDICE
+     * do token consumido (não só seu valor string) para evitar bug onde
+     * `tokens.indexOf(value)` retorna sempre a 1ª ocorrência — quebrando
+     * em inputs com tokens repetidos ("vermelho borda vermelho").
+     */
+    readonly tokenIndex: number;
+}
+/**
+ * Política de distância adaptativa por tamanho do termo:
+ * - Termos ≤ 3 chars: distância máxima 0 (matches exatos só — "rect",
+ *   "red" são tão curtas que 1 typo já vira outra palavra).
+ * - Termos 4–6 chars: distância máxima 1.
+ * - Termos ≥ 7 chars: distância máxima 2.
+ *
+ * Cap absoluto: 2 (acima disso é palavra diferente, não typo).
+ */
+declare function adaptiveMaxDistance(termLength: number): number;
+/**
+ * Tenta casar um único token de input contra uma lista de termos
+ * (keys de dicionário OU keywords de intent), respeitando distância
+ * adaptativa por tamanho do termo.
+ *
+ * **Retorno**: melhor match (menor distância) ou `null` se nenhum
+ * dentro do orçamento de distância adaptativo.
+ *
+ * **Custo**: O(N) onde N = `terms.length`, com early termination
+ * herdada do `levenshtein()`.
+ */
+declare function fuzzyMatchToken(token: string, terms: readonly string[]): FuzzyMatch | null;
+/**
+ * Match fuzzy de **qualquer** token de uma lista contra **qualquer**
+ * termo de uma lista. Retorna o melhor casamento (ou `null`).
+ *
+ * Útil pra "alguma das keywords da intent aparece no input?". Pára
+ * cedo no primeiro match exato (distância 0).
+ */
+declare function fuzzyMatchAny(tokens: readonly string[], terms: readonly string[]): FuzzyMatch | null;
+/**
+ * Versão "all matches" — retorna **todos** os matches fuzzy de um
+ * token contra a lista, sem early-termination. Útil quando precisamos
+ * de ranking completo (intent registry com muitos candidates).
+ */
+declare function fuzzyMatchAll(token: string, terms: readonly string[], maxDistOverride?: number): readonly FuzzyMatch[];
+
+/**
+ * Resultado da extração: valores por nome de slot. Slots não
+ * encontrados são `undefined` (caller decide se aplica default).
+ */
+type ExtractedSlots = Record<string, unknown>;
+/**
+ * Indica quais tokens foram consumidos por matchings (keywords/
+ * actions/slots) — útil pra evitar dupla atribuição (token "100"
+ * não deve preencher dois slots `number` distintos).
+ */
+interface ExtractContext {
+    /** Set mutável de índices de tokens já consumidos. */
+    readonly consumedIndices: Set<number>;
+}
+/**
+ * Parse um token como número. Aceita "100", "1.5", "1,5", "100px".
+ * Trata `,` como separador decimal (PT). Não aceita signos relativos
+ * exóticos. Retorna `null` quando não é número.
+ */
+declare function parseNumberToken(token: string): number | null;
+/**
+ * Tenta resolver um token ISOLADO como cor: hex direto, rgb/hsl
+ * funcional OU lookup no dicionário com fuzzy match (dist ≤ 1 pra
+ * typos como "vermelo"). Para frases com intensificador adjacente
+ * ("azul claro"), use {@link parseColorPhrase}.
+ */
+declare function parseColorToken(token: string): string | null;
+/**
+ * Resultado de {@link parseColorPhrase}: cor resolvida + quantos
+ * tokens adjacentes foram consumidos (sempre ≥ 1).
+ */
+interface ColorPhraseMatch {
+    /** Cor resolvida (`#rrggbb`, CSS keyword, ou outro do dicionário). */
+    readonly color: string;
+    /**
+     * Quantos tokens (a partir de `startIdx`) compõem a frase de cor.
+     * Sempre ≥ 1. Caller deve marcar todos esses índices como consumed.
+     *
+     * Exemplos:
+     * - "azul" → tokensConsumed = 1
+     * - "azul claro" → tokensConsumed = 2 (intensificador adjacente)
+     * - "bem azul escuro" → tokensConsumed = 3 (multiplier + cor + mod)
+     * - "muito claro azul" → tokensConsumed = 3 (multiplier + mod ANTES da cor)
+     */
+    readonly tokensConsumed: number;
+}
+/**
+ * Resolve uma cor a partir de `tokens[startIdx]`, considerando
+ * **intensificadores adjacentes** que modificam o lightness do hex
+ * base. Suporta padrões:
+ *
+ * - `[modifier] cor [modifier]` — "azul claro" / "claro azul" /
+ *   "verde escuro" / "dark green"
+ * - `[multiplier] [modifier] cor` — "muito claro azul" / "very
+ *   dark red"
+ * - `cor [multiplier] [modifier]` — "verde bem escuro" / "blue
+ *   really dark"
+ *
+ * Não modifica `none` / `currentColor` / `inherit` (sem hex base).
+ *
+ * Retorna `null` quando `tokens[startIdx]` não é cor nem
+ * intensificador-seguido-de-cor.
+ */
+declare function parseColorPhrase(tokens: readonly string[], startIdx: number): ColorPhraseMatch | null;
+/**
+ * Extrai dimensão composta `100x50` em `{ width, height }` quando
+ * presente. Retorna `null` quando o token não é dimensão.
+ */
+declare function parseDimensionToken(token: string): {
+    width: number;
+    height: number;
+} | null;
+/**
+ * Extrai os slots declarados em `schemas` a partir dos `tokens`,
+ * marcando consumed indices no `ctx`.
+ *
+ * **Algoritmo (single pass por slot, ordem declarada)**:
+ * 1. Para cada slot, varre tokens ainda não consumidos.
+ * 2. Tenta resolver de acordo com o `kind`.
+ * 3. Se encontrar, marca consumed + atribui ao slot.
+ * 4. Aplica `default` quando não encontrou + `optional: true`.
+ *
+ * **Edge case `kind: 'number'`** com dimensão `100x50`: se houver
+ * slot `width` E `height` no schema (nessa ordem), o token de
+ * dimensão preenche os dois e consome o índice uma vez. Caso
+ * contrário, só o primeiro number do par é usado.
+ *
+ * **Edge case `kind: 'color'`** com intensificador adjacente
+ * ("azul claro"): {@link parseColorPhrase} consome todos os
+ * tokens da frase de cor — caller marca múltiplos consumed indices.
+ */
+declare function extractSlots(tokens: readonly string[], schemas: Record<string, NluSlotSchema>, ctx?: ExtractContext): ExtractedSlots;
+
+/**
+ * Color parsing helpers — D-046 Fase 1 enrich.
+ *
+ * Reconhece formatos CSS além de hex puro:
+ * - `rgb(255, 0, 0)` / `rgba(255, 0, 0, 0.5)`
+ * - `hsl(0, 100%, 50%)` / `hsla(0, 100%, 50%, 0.5)`
+ * - Hex (3, 4, 6, 8 dígitos) — delegado pro caller via `HEX_COLOR_RE`
+ *
+ * Também expõe `lightenHex` / `darkenHex` usados pelos intensificadores
+ * ("azul claro" / "verde escuro" / "bem escuro") no slot extractor.
+ *
+ * **Por que arquivo separado** (em vez de empilhar tudo no
+ * slot-extractor): coesão. Color math é responsabilidade única;
+ * tornar reaproveitável por outros parsers / plugins / UI components.
+ *
+ * **Sem dependências externas** (requisito Fase 1).
+ */
+/** Hex 3, 4, 6 ou 8 dígitos (com `#`). */
+declare const HEX_COLOR_RE: RegExp;
+/**
+ * Parse `rgb(...)` / `rgba(...)` → hex (ignora alpha por ora, sem
+ * suporte a alpha no slot color). Retorna `null` se não casar.
+ */
+declare function parseRgbFunction(input: string): string | null;
+/**
+ * Parse `hsl(...)` / `hsla(...)` → hex. Retorna `null` se não casar.
+ */
+declare function parseHslFunction(input: string): string | null;
+/**
+ * Vocabulário de intensificadores que **modificam** uma cor adjacente.
+ * `delta` é a variação de lightness (HSL, 0..1) aplicada ao hex base.
+ * Positivo = mais claro, negativo = mais escuro.
+ *
+ * Multiplicador "bem" / "muito" / "very" / "really" dobra o efeito do
+ * intensificador subsequente (vide `LIGHTNESS_MULTIPLIERS`).
+ */
+declare const LIGHTNESS_MODIFIERS: Readonly<Record<string, number>>;
+/**
+ * Multiplicadores que amplificam o intensificador SEGUINTE.
+ * "bem escuro" / "muito claro" / "very dark" → multiplica o delta.
+ */
+declare const LIGHTNESS_MULTIPLIERS: Readonly<Record<string, number>>;
+/**
+ * Aplica delta de lightness a um hex `#rrggbb` (ou `#rgb`). Mantém
+ * matiz e saturação; só altera L no espaço HSL.
+ */
+declare function adjustHexLightness(hex: string, delta: number): string;
+/** Conveniência: clarear. */
+declare function lightenHex(hex: string, amount?: number): string;
+/** Conveniência: escurecer. */
+declare function darkenHex(hex: string, amount?: number): string;
+/**
+ * `#rrggbb` (ou `#rgb`) → `[r, g, b]` em [0, 255]. `null` se inválido.
+ * Ignora alpha quando 4 ou 8 dígitos.
+ */
+declare function hexToRgb(hex: string): [number, number, number] | null;
+/** RGB [0,255] → HSL [h:0-360, s:0-1, l:0-1]. */
+declare function rgbToHsl(r: number, g: number, b: number): [number, number, number];
+/** HSL [h:0-360, s:0-1, l:0-1] → RGB [0,255]. */
+declare function hslToRgb(h: number, s: number, l: number): [number, number, number];
+
+/**
+ * **Color dictionary — English (EN).**
+ *
+ * Kept separate from PT so idiomatic / regional variants can be reviewed
+ * independently. Final dict consumed by the parser
+ * (`COLOR_DICTIONARY` in `colors.ts`) merges PT + EN.
+ *
+ * **Key convention**: lowercase, no diacritics (tokenizer applies
+ * `deaccent()` before lookup). Don't duplicate with PT — when a token
+ * is the same in both (e.g., CSS keywords like `'royalblue'`), keep
+ * it ONLY here.
+ *
+ * **Why split by language**:
+ * - Audit: spot vocabulary gaps PT vs EN without scanning 200 lines.
+ * - Maintenance: extend EN dict without touching PT.
+ * - Language detection (`detectLanguage()` in `language-detect.ts`)
+ *   uses per-dict hit counts to estimate the dominant input language.
+ */
+declare const COLOR_DICTIONARY_EN: Readonly<Record<string, string>>;
+
+/**
+ * **Dicionário de cores — Português (PT-BR/PT-PT).**
+ *
+ * Mantido **separado de EN** pra que extensões idiomáticas / regionais
+ * (variantes brasileiras vs portuguesas, gírias, neologismos) possam
+ * ser revisadas isoladamente. O dict final consumido pelo parser
+ * (`COLOR_DICTIONARY` em `colors.ts`) faz merge de PT + EN.
+ *
+ * **Convenção de chave**: lowercase + SEM acento (o tokenizer aplica
+ * `deaccent()` antes da busca). NÃO duplicar com EN — se a palavra é a
+ * mesma nos dois idiomas (e.g., `'royalblue'` é universal CSS), coloque
+ * SÓ em `colors-en.ts`.
+ *
+ * **Por que separar por idioma**:
+ * - Auditoria: ver lacunas de vocabulário PT vs EN sem ler 200 linhas.
+ * - Manutenção: adicionar variante regional sem tocar EN.
+ * - Detecção de idioma (`detectLanguage()` em `language-detect.ts`)
+ *   usa contagem de hits por dict pra estimar idioma dominante.
+ */
+declare const COLOR_DICTIONARY_PT: Readonly<Record<string, string>>;
+
+/**
+ * **Merged dict** — PT + EN. EN tem precedência em colisão (mas como
+ * convencionamos não duplicar, colisões só acontecem em CSS keywords
+ * universais — comportamento idempotente).
+ */
+declare const COLOR_DICTIONARY: Readonly<Record<string, string>>;
+/**
+ * Lista de keys (lowercase, sem acento) — usada pelo fuzzy matcher
+ * pra propor cores próximas quando o usuário digita errado
+ * ("vermelo" → "vermelho").
+ */
+declare const COLOR_KEYS: readonly string[];
+/**
+ * Resolve um nome de cor (lowercased, deacentuado) para hex/CSS.
+ * Retorna `null` quando o nome não consta no dicionário.
+ *
+ * **Multi-idioma**: consulta o merged dict (PT + EN), então funciona
+ * pra qualquer input independente do idioma do usuário.
+ */
+declare function resolveColorName(name: string): string | null;
+
+/**
+ * **NLU-specific shape vocabulary** — separado do `ShapeKind` em
+ * `svg-engine/edit/lib/tool` (que tem `'rect' | 'ellipse' | 'polygon'`
+ * pras shape tools de drawing). O NLU precisa de uma lista maior
+ * porque mapeia vocabulário falado/escrito, não capability de tool.
+ *
+ * **Polígonos específicos** (D-046 review-5): triangle/pentagon/
+ * hexagon/octagon/rhombus/star são kinds próprios para que o handler
+ * `create-shape` saiba **quantos lados** gerar sem precisar inferir
+ * do input. Antes, "triangulo" e "hexagono" caíam em `'polygon'`
+ * genérico e o handler não tinha info pra desenhar — virava no-op.
+ */
+type NluShapeKind = 'rect' | 'ellipse' | 'circle' | 'line' | 'path' | 'triangle' | 'rhombus' | 'pentagon' | 'hexagon' | 'octagon' | 'star' | 'polygon' | 'polyline' | 'text' | 'image' | 'group' | 'svg';
+
+/**
+ * **Shape dictionary — English.**
+ *
+ * Maps EN vocabulary (technical names + common UX semantic aliases)
+ * to {@link NluShapeKind} canonical. Kept separate from PT for clarity.
+ *
+ * **Key convention**: lowercase, no diacritics.
+ */
+
+declare const SHAPE_DICTIONARY_EN: Readonly<Record<string, NluShapeKind>>;
+
+/**
+ * **Dicionário de formas — Português.**
+ *
+ * Mapeia vocabulário PT (nomes técnicos + semanticos UX) pra
+ * {@link NluShapeKind} canonical. Separado de EN pra cobrir variantes
+ * regionais isoladamente. Final merged em `shapes.ts`.
+ *
+ * **Convenção de chave**: lowercase + SEM acento.
+ */
+
+declare const SHAPE_DICTIONARY_PT: Readonly<Record<string, NluShapeKind>>;
+
+/**
+ * Dicionário de formas — **PT + EN merged** → canonical shape kind.
+ *
+ * O kind canonical mapeia para os factories existentes em
+ * `svg-engine/core` (`createRect`, `createEllipse`, `createPath`,
+ * `createLine`, `createPolygon`, `createPolyline`, `createText`,
+ * `createImage`, `createGroup`). Plugins built-in usam esse mapeamento
+ * pra resolver o slot `shape` (e.g., "criar retângulo" → `rect` →
+ * `createRect`).
+ *
+ * **Convenções de chaves**:
+ * - **lowercase + SEM acento** (tokenizer faz `deaccent()` antes).
+ * - PT/EN vivem em arquivos separados (`shapes-pt.ts`, `shapes-en.ts`).
+ * - Quando uma palavra é idêntica nos dois idiomas, fica APENAS em EN.
+ * - **Semantic aliases** ("nó" → circle, "conector" → line, "balão"
+ *   → group) mapeiam vocabulário UX para shapes existentes.
+ *
+ * **Geometria por nome**: "estrela" mapeia para `'star'` com geometria
+ * real (5 pontas via `regularStarPoints`); "coração" cai em `'star'`
+ * como fallback semântico até ganhar geometria própria. Outros ícones
+ * nomeados ainda fora do vocabulário ficam para a fase que integrar
+ * uma icon library (Fase 1.x).
+ */
+
+declare const SHAPE_DICTIONARY: Readonly<Record<string, NluShapeKind>>;
+/** Keys disponíveis pro fuzzy matcher. */
+declare const SHAPE_KEYS: readonly string[];
+/**
+ * Resolve um nome de forma (lowercased + deacentuado) para kind.
+ * Retorna `null` quando não é uma forma conhecida.
+ *
+ * **Multi-idioma**: consulta o merged dict (PT + EN).
+ */
+declare function resolveShapeKind(name: string): NluShapeKind | null;
+
+/**
+ * **Action canonicals** — vocabulário fechado de verbos suportados.
+ *
+ * Cada termo PT ou EN é mapeado pra um canonical aqui. Plugins NLU
+ * declaram `actionKeywords: ['create', 'delete']` (canonicals) em
+ * vez de listar todas as conjugações — o `resolveActionCanonical(token)`
+ * faz a tradução transparente.
+ *
+ * **Por que canonical em vez de só strings**:
+ * - TypeScript valida cobertura nos consumers (intent não pode
+ *   declarar action que não existe).
+ * - Refactor de vocabulário sem quebrar intents (renomear `'paint'`
+ *   pra `'fill'` é mudança LOCAL aqui + nas tabelas).
+ *
+ * **Adicionar canonical novo**: 1) adiciona aqui, 2) adiciona entradas
+ * em `actions-pt.ts` E `actions-en.ts`, 3) consumer plugin declara em
+ * `intent.actionKeywords`. Sem step 3 o canonical é "registrado mas
+ * não usado" — não quebra, mas é code-smell.
+ */
+type ActionCanonical = 'create' | 'delete' | 'select' | 'select-all' | 'deselect' | 'group' | 'ungroup' | 'undo' | 'redo' | 'zoom-in' | 'zoom-out' | 'zoom-reset' | 'copy' | 'paste' | 'cut' | 'duplicate' | 'move' | 'rotate' | 'resize' | 'flip' | 'align' | 'distribute' | 'bring-forward' | 'send-backward' | 'show' | 'hide' | 'toggle' | 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'convert' | 'lock' | 'unlock' | 'export' | 'import';
+
+/**
+ * **Action dictionary — English.**
+ *
+ * Maps EN verbs (base form + common synonyms) to the canonical token
+ * shared with PT. Keep entries minimal and synonyms commonly seen in
+ * UI / spoken English; avoid archaic forms.
+ *
+ * **Key convention**: lowercase, no diacritics. Same canonical as PT
+ * (verified by `ActionCanonical` type).
+ */
+
+declare const ACTION_DICTIONARY_EN: Readonly<Record<string, ActionCanonical>>;
+
+/**
+ * **Dicionário de ações — Português.**
+ *
+ * Mapeia conjugações PT comuns (infinitivo + imperativo afirmativo)
+ * para o termo canonical (`'create'`, `'delete'`, etc) compartilhado
+ * com EN. Mantido separado pra cobrir variações regionais sem ruído.
+ *
+ * **Convenção de chave**: lowercase + SEM acento.
+ * **Cobertura mínima**: pra cada verbo, infinitivo (`mover`) +
+ * imperativo formal (`mova`) + imperativo informal (`movimente`).
+ */
+
+declare const ACTION_DICTIONARY_PT: Readonly<Record<string, ActionCanonical>>;
+
+/**
+ * **Merged dict** — PT + EN. EN tem precedência em colisão (mas
+ * convencionamos não duplicar — colisões só acontecem em CSS keywords).
+ */
+declare const ACTION_DICTIONARY: Readonly<Record<string, ActionCanonical>>;
+/** Keys disponíveis pro fuzzy matcher. */
+declare const ACTION_KEYS: readonly string[];
+/**
+ * Resolve uma palavra (lowercased + deacentuada) para ação canonical.
+ * Retorna `null` quando não é verbo conhecido.
+ *
+ * **Multi-idioma**: consulta o merged dict (PT + EN), então funciona
+ * pra qualquer input independente do idioma do usuário.
+ */
+declare function resolveActionCanonical(word: string): ActionCanonical | null;
+
+/**
+ * **Stopwords — English.**
+ *
+ * Low-information words ignored by the parser to avoid noise in
+ * keyword/action/slot matching. Includes articles, prepositions,
+ * conjunctions, pronouns, conversational fillers and weak modal verbs.
+ *
+ * Does NOT include action verbs ("create", "delete") — those live in
+ * `actions-en.ts`. Nor colors/shapes (those are slot values).
+ *
+ * **Key convention**: lowercase, no diacritics.
+ */
+declare const STOPWORDS_EN: ReadonlySet<string>;
+
+/**
+ * **Stopwords — Português.**
+ *
+ * Palavras de baixa informação ignoradas pelo parser pra evitar ruído
+ * no matching de keywords/actions/slots. Inclui artigos, preposições,
+ * conjunções, pronomes, fillers conversacionais e verbos auxiliares
+ * fracos que aparecem em comandos coloquiais.
+ *
+ * **Não inclui** verbos de ação ("criar", "deletar"); esses estão em
+ * `actions-pt.ts`. Nem cores/formas (esses são slot values).
+ *
+ * **Convenção de chave**: lowercase + SEM acento (consistente com
+ * o tokenizer — `deaccent()` é aplicado antes do lookup).
+ */
+declare const STOPWORDS_PT: ReadonlySet<string>;
+
+/** **Merged set** — PT ∪ EN. */
+declare const STOPWORDS: ReadonlySet<string>;
+/**
+ * `true` se o token é uma stopword (case-insensitive, sem acento).
+ * O caller é responsável por já ter tokenizado/normalizado.
+ *
+ * **Multi-idioma**: cobre PT + EN no mesmo set.
+ */
+declare function isStopword(token: string): boolean;
+
+/** Idiomas suportados oficialmente pela NLU. */
+type NluLanguage = 'pt' | 'en' | 'unknown';
+/**
+ * Resultado da detecção — idioma + contagem de hits por dict pra debug.
+ */
+interface LanguageDetectResult {
+    readonly language: NluLanguage;
+    readonly hits: {
+        readonly pt: number;
+        readonly en: number;
+    };
+}
+/**
+ * Detecta idioma dominante de uma sequência de tokens (já
+ * tokenizados via `tokenize()`).
+ *
+ * **Retorna `'unknown'`** quando:
+ * - Zero tokens
+ * - Zero hits em ambos os idiomas (texto só de números/hex/símbolos)
+ * - Empate exato (igual número de hits PT e EN)
+ *
+ * Caller decide o fallback (default PT? Persistido na UI?).
+ */
+declare function detectLanguage(tokens: readonly string[]): LanguageDetectResult;
+
+/**
+ * **Number words — PT + EN.**
+ *
+ * Mapeia palavras de número escritas por extenso (PT/EN) para valor
+ * numérico inteiro. Usado pelo `parseNumberToken` no slot-extractor
+ * pra reconhecer comandos como "selecionar os três triangulos" →
+ * count=3.
+ *
+ * **Cobertura**: 1-20 + dezenas (30, 40, ..., 100). Acima disso é
+ * raro em comandos de editor SVG ("selecionar os 50 retangulos" é
+ * mais natural com dígito).
+ *
+ * **Convenção de chave**: lowercase + SEM acento (tokenizer faz
+ * `deaccent()`). Tres → `tres`, dois → `dois`, etc.
+ */
+declare const NUMBER_WORDS: Readonly<Record<string, number>>;
+/**
+ * Resolve uma palavra de número (lowercased, deacentuada) pro valor
+ * inteiro. Retorna `null` quando não é número conhecido.
+ */
+declare function resolveNumberWord(word: string): number | null;
+
+/**
+ * **`NluDictionaryRegistry`** — D-046 review-10 (Sprint 2.B / H5).
+ *
+ * Service injetável que permite consumers ESTENDEREM o vocabulário NLU
+ * em runtime, sem editar os arquivos source dos dicts built-in
+ * (`colors-*.ts`, `shapes-*.ts`, `actions-*.ts`).
+ *
+ * **Motivação**: aplicações de domínio (fluxograma, BPMN, UML, mapas)
+ * têm vocabulário próprio ("swimlane", "decision", "actor", "use-case").
+ * Sem este registry, a única forma de cobrir é editar source ou
+ * registrar 20+ intents customizados duplicados.
+ *
+ * **API**:
+ * - `registerColor(name, hex)` — adiciona "vibrant-blue" → "#1e90ff"
+ * - `registerShape(name, kind)` — adiciona "actor" → 'circle' alias
+ * - `registerAction(word, canonical)` — adiciona "compor" → 'create'
+ * - `resolveColor` / `resolveShape` / `resolveAction` — consultam
+ *   dinâmico ANTES dos built-in (override permitido)
+ *
+ * **Multi-editor (D-042)**: singleton root-provided, mas extensions
+ * são compartilhadas entre todos os editors. Plugins por-editor
+ * podem usar `track(disposable)` pra cleanup.
+ *
+ * **Estado atual** (Fase 1): este registry é OPCIONAL. O parser
+ * (`slot-extractor`, `menu-intent-discovery`) ainda consulta dicts
+ * estáticos diretamente. Integração com este registry fica como
+ * Sprint futuro (refactor de `resolveColorName` pra usar override
+ * dinâmico, etc).
+ */
+declare class NluDictionaryRegistry {
+    private readonly _colors;
+    private readonly _shapes;
+    private readonly _actions;
+    /** Snapshot reativo das cores customizadas. */
+    readonly colors: Signal<ReadonlyMap<string, string>>;
+    /** Snapshot reativo das shapes customizadas. */
+    readonly shapes: Signal<ReadonlyMap<string, NluShapeKind>>;
+    /** Snapshot reativo das actions customizadas. */
+    readonly actions: Signal<ReadonlyMap<string, ActionCanonical>>;
+    /**
+     * Adiciona uma entrada de cor customizada. Retorna `Disposable` pra
+     * remover (em geral trackeada por plugin via `ctx.track()`).
+     *
+     * @param name nome normalizado (lowercase, sem acento). Conflitos
+     *   com built-in fazem **override** silencioso (consumer tem prioridade).
+     * @param hex CSS color (`#rrggbb`, `rgb(...)`, keyword) ou `'none'`/`'transparent'`.
+     */
+    registerColor(name: string, hex: string): Disposable;
+    /**
+     * Adiciona uma entrada de shape customizada (alias semântico).
+     *
+     * @param name nome normalizado.
+     * @param kind {@link NluShapeKind} canonical.
+     */
+    registerShape(name: string, kind: NluShapeKind): Disposable;
+    /**
+     * Adiciona uma palavra de ação customizada → canonical existente.
+     *
+     * @param word palavra normalizada.
+     * @param canonical {@link ActionCanonical} existente.
+     */
+    registerAction(word: string, canonical: ActionCanonical): Disposable;
+    /**
+     * Resolve cor consultando PRIMEIRO o registry dinâmico (consumer
+     * tem prioridade), DEPOIS o dict estático built-in. Retorna `null`
+     * quando não encontra.
+     */
+    resolveColor(name: string): string | null;
+    /** Resolve shape no registry dinâmico (null se não encontrar). */
+    resolveShape(name: string): NluShapeKind | null;
+    /** Resolve action canonical no registry dinâmico (null se não). */
+    resolveAction(word: string): ActionCanonical | null;
+    /**
+     * Helper genérico — registra entrada com validação básica e retorna
+     * Disposable. Não-throw em conflito (override silencioso).
+     */
+    private registerEntry;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NluDictionaryRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NluDictionaryRegistry>;
+}
+
+/**
+ * **Contrato de voz desacoplado** — D-046 voz híbrida.
+ *
+ * Define a abstração `VoiceProvider` num lugar **headless** (sem
+ * Material, sem transformers.js) para que tanto a camada de UI
+ * (`svg-engine/ai/nlu-ui`, provider Web Speech) quanto a camada WASM
+ * (`svg-engine/ai/nlu-voice-wasm`, provider Whisper local) possam
+ * compartilhar o mesmo contrato **sem dependência cruzada** entre elas.
+ *
+ * O orquestrador (`VoiceEngineService`, em `nlu-ui`) injeta o provider
+ * Web Speech diretamente e o provider Whisper **opcionalmente** via
+ * {@link VOICE_WHISPER_PROVIDER} — registrado pelo app só quando a voz
+ * local é desejada (`provideWhisperVoiceEngine()`).
+ */
+/**
+ * Engine de reconhecimento de voz escolhível pelo usuário:
+ * - `'web-speech'` — Web Speech API nativa do navegador (rápida, mas
+ *   depende de STT em nuvem do vendor — pode falhar com `network`).
+ * - `'whisper'` — Whisper local via WASM (100% offline, sem rede).
+ * - `'auto'` — tenta Web Speech e, em falha, cai para o Whisper.
+ */
+type VoiceEngine = 'web-speech' | 'whisper' | 'auto';
+/**
+ * Surface mínima comum de um provider de reconhecimento de voz.
+ * Tanto `VoiceRecognitionService` (Web Speech) quanto
+ * `WhisperVoiceService` (WASM) a satisfazem **estruturalmente** — não
+ * é preciso `implements` nominal.
+ */
+interface VoiceProvider {
+    /** `false` quando o ambiente não suporta esta engine. */
+    readonly isSupported: Signal<boolean>;
+    /** `true` enquanto captura/processa. */
+    readonly listening: Signal<boolean>;
+    /** Último código de erro (`'network'`, `'not-allowed'`, …) ou `null`. */
+    readonly lastError: Signal<string | null>;
+    /** `true` durante carregamento de modelo (só engines com modelo, ex. Whisper). */
+    readonly modelLoading?: Signal<boolean>;
+    /** Inicia a captura; resolve com a transcrição final. */
+    listen(lang?: string, options?: {
+        readonly timeoutMs?: number;
+    }): Promise<string>;
+    /** Encerra a captura ativa, se houver. */
+    stop(): void;
+}
+/**
+ * Token DI **opcional** do provider Whisper local. Default `null`
+ * (voz local não instalada). Apps que querem o Whisper offline
+ * registram via `provideWhisperVoiceEngine()` de
+ * `svg-engine/ai/nlu-voice-wasm`.
+ */
+declare const VOICE_WHISPER_PROVIDER: InjectionToken<VoiceProvider | null>;
+
+/**
+ * **D-093 — contrato de provedor LLM (chat) desacoplado.**
+ *
+ * Define a abstração `AiChatProvider` num lugar **headless** (sem rede
+ * amarrada, sem Material) — exatamente como o {@link VoiceProvider} fez
+ * para voz. Qualquer backend (Ollama local, OpenAI, Anthropic, vLLM…)
+ * que satisfaça este contrato pode alimentar o {@link LlmIntentResolverService}
+ * sem que o resolver saiba qual é.
+ *
+ * O resolver injeta o provider **opcionalmente** via {@link AI_CHAT_PROVIDER}
+ * (default `null` — LLM não instalado). Apps que querem a camada LLM
+ * registram um provider concreto (ex.: `provideOllamaChat(...)`).
+ */
+/** Papel de uma mensagem no diálogo (formato estilo chat completions). */
+type AiChatRole = 'system' | 'user' | 'assistant';
+/** Uma mensagem do diálogo enviada ao modelo. */
+interface AiChatMessage {
+    readonly role: AiChatRole;
+    readonly content: string;
+}
+/**
+ * Opções por-chamada. Tudo opcional — o provider aplica seus defaults.
+ *
+ * **`model`** é o ponto-chave do requisito do usuário: permite **trocar
+ * o modelo por requisição conforme a complexidade** do conteúdo (ex.:
+ * `qwen2.5:3b` para o trivial, `qwen2.5:7b` para composições pesadas)
+ * sem reconfigurar o provider.
+ */
+interface AiChatOptions {
+    /** Sobrescreve o modelo do provider só nesta chamada (roteamento por complexidade). */
+    readonly model?: string;
+    /** Pede saída **JSON** estruturada (mapeia para `format:"json"` no Ollama). */
+    readonly format?: 'json';
+    /** Temperatura de amostragem (0 = determinístico). */
+    readonly temperature?: number;
+    /** Teto de tokens gerados (mapeia para `num_predict` no Ollama). */
+    readonly maxTokens?: number;
+    /** Cancela a chamada (timeout / troca de contexto). */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Surface mínima de um provedor de chat LLM. Satisfeito
+ * **estruturalmente** — não exige `implements` nominal.
+ */
+interface AiChatProvider {
+    /** `false` quando o provider não está utilizável (sem baseUrl, etc.). */
+    readonly isConfigured: Signal<boolean>;
+    /** Modelo default deste provider (o usado quando `opts.model` é omitido). */
+    readonly defaultModel: Signal<string>;
+    /**
+     * **D-095 — modelos sugeridos** (curados/conhecidos), opcional. A UI funde
+     * esta lista com os modelos descobertos ao vivo ({@link
+     * AiChatProvider.listModels}) para popular o seletor — útil de fallback
+     * quando a descoberta falha e como sugestão para consumidores. Backends sem
+     * curadoria simplesmente não expõem (a UI cai nos descobertos + default).
+     */
+    readonly suggestedModels?: Signal<readonly string[]>;
+    /**
+     * Envia o diálogo e resolve com o **texto** da resposta do assistente.
+     * Lança em erro de rede / HTTP — o chamador (resolver) trata.
+     */
+    chat(messages: readonly AiChatMessage[], opts?: AiChatOptions): Promise<string>;
+    /**
+     * **D-094 — descoberta de modelos** (opcional). Lista os modelos
+     * disponíveis no backend para o usuário escolher (ex.: Ollama
+     * `GET /api/tags`). O contrato é opcional: backends que não expõem um
+     * catálogo (ou que só servem um modelo) simplesmente não implementam, e
+     * a UI cai no {@link AiChatProvider.defaultModel}. Lança em erro de rede
+     * / HTTP — o chamador trata e degrada para o default.
+     */
+    listModels?(): Promise<readonly string[]>;
+}
+/**
+ * Token DI **opcional** do provedor LLM. Default `null` (camada LLM não
+ * instalada → o {@link LlmIntentResolverService} reporta `isAvailable === false`
+ * e o app continua só com o NLU rule-based). Apps registram um provider
+ * concreto via, p.ex., `provideOllamaChat({ baseUrl, model })`.
+ */
+declare const AI_CHAT_PROVIDER: InjectionToken<AiChatProvider | null>;
+
+/** Default Ollama endpoint (local). Override via {@link provideOllamaChat}. */
+declare const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+/** Default model — the small/fast one that fits a modest GPU (D-093 benchmark). */
+declare const DEFAULT_OLLAMA_MODEL = "qwen2.5:3b";
+/**
+ * **D-095 — modelos curados (conhecidos) sugeridos no seletor.**
+ *
+ * Lista de fallback/curadoria que o `<svge-nlu-input>` funde com os modelos
+ * **descobertos** ao vivo (`/api/tags`): garante que esses apareçam no seletor
+ * mesmo quando a descoberta falha (servidor offline/sem CORS) e serve de
+ * sugestão para consumidores da lib que ainda não puxaram nada.
+ *
+ * Inclui os modelos base (D-093) **e** os **`qwen2.5-coder`** (3b/7b/14b) —
+ * estes últimos são **coder-tuned**, logo bem melhores para gerar SVG (que é
+ * markup/código): fecham tags, respeitam `viewBox`/`path`/`defs`. Mantidos os
+ * anteriores; os coder são **adicionais** (vide D-094 modo "SVG livre").
+ */
+declare const DEFAULT_OLLAMA_MODELS: readonly string[];
+/** Optional configuration for {@link OllamaChatProvider} / {@link provideOllamaChat}. */
+interface OllamaChatConfig {
+    /** Base URL of the Ollama server, e.g. `http://192.168.1.21:11434`. */
+    readonly baseUrl?: string;
+    /** Default model id, e.g. `qwen2.5:3b`. Overridable per-call via `opts.model`. */
+    readonly model?: string;
+    /**
+     * **D-095** — sobrescreve a lista curada de modelos sugeridos no seletor
+     * ({@link DEFAULT_OLLAMA_MODELS}). Quando omitido, usa a curadoria padrão.
+     */
+    readonly models?: readonly string[];
+}
+/**
+ * **D-093 — `AiChatProvider` para Ollama** (API nativa `/api/chat`).
+ *
+ * `fetch` puro contra um servidor Ollama. Sem dependência pesada (ao
+ * contrário do Whisper), então mora no mesmo entry point `svg-engine/ai/nlu`
+ * junto do contrato — o token {@link AI_CHAT_PROVIDER} mantém a troca de
+ * backend desacoplada.
+ *
+ * **baseUrl/model são signals settáveis em runtime** — atende o requisito
+ * de "trocar provider/model conforme a complexidade": o app pode chamar
+ * `setModel('qwen2.5:7b')` para conteúdo pesado, ou passar `opts.model`
+ * por chamada (sem mexer no default).
+ *
+ * **CORS**: o servidor Ollama precisa subir com `OLLAMA_ORIGINS` liberando
+ * a origem do app (validado no D-093). Erros de rede/HTTP são propagados
+ * via `throw` — o {@link LlmIntentResolverService} captura e degrada.
+ */
+declare class OllamaChatProvider implements AiChatProvider {
+    private readonly _baseUrl;
+    private readonly _model;
+    private readonly _suggestedModels;
+    /** Current base URL (reactive). */
+    readonly baseUrl: i0.Signal<string>;
+    /** Current default model (reactive). Satisfies {@link AiChatProvider.defaultModel}. */
+    readonly defaultModel: i0.Signal<string>;
+    /**
+     * **D-095** — modelos curados sugeridos no seletor (reactive). Satisfaz
+     * {@link AiChatProvider.suggestedModels}. Fundidos com os descobertos via
+     * `/api/tags` pela UI; default = {@link DEFAULT_OLLAMA_MODELS}.
+     */
+    readonly suggestedModels: i0.Signal<readonly string[]>;
+    /** `true` once a non-empty base URL is set (it always is, by default). */
+    readonly isConfigured: i0.Signal<boolean>;
+    /** Apply a partial config (only the provided fields change). */
+    configure(cfg: OllamaChatConfig): void;
+    /** Switch the server URL at runtime. */
+    setBaseUrl(url: string): void;
+    /** Switch the default model at runtime (complexity routing). */
+    setModel(model: string): void;
+    chat(messages: readonly AiChatMessage[], opts?: AiChatOptions): Promise<string>;
+    /**
+     * **D-094** — lista os modelos instalados no servidor Ollama via
+     * `GET /api/tags`. Alimenta o seletor de modelo da UI (o usuário escolhe
+     * entre os modelos disponíveis em runtime). Devolve os nomes (`name`,
+     * ex.: `qwen2.5:3b`) ordenados alfabeticamente e deduplicados. Propaga
+     * erro de rede / HTTP — o chamador degrada para o {@link defaultModel}.
+     */
+    listModels(): Promise<readonly string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OllamaChatProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OllamaChatProvider>;
+}
+/**
+ * **D-093** — DI helper that wires {@link OllamaChatProvider} as the active
+ * {@link AI_CHAT_PROVIDER}. Add to an app/route `providers: []`:
+ *
+ * ```ts
+ * providers: [
+ *   provideOllamaChat({ baseUrl: 'http://192.168.1.21:11434', model: 'qwen2.5:3b' }),
+ * ]
+ * ```
+ *
+ * The same instance is reachable as both {@link OllamaChatProvider} (for
+ * runtime `setModel`/`setBaseUrl`) and {@link AI_CHAT_PROVIDER} (what the
+ * resolver consumes).
+ */
+declare function provideOllamaChat(cfg?: OllamaChatConfig): Provider[];
+
+/**
+ * **D-093 Fase 4** — teto de entradas no catálogo enviado ao modelo.
+ *
+ * Descoberta empírica (teste ao vivo 3b E 7b): com os 222 intents
+ * registrados o prompt chega a ~4095 tokens — **~74s só de ingestão**
+ * nessa GPU — e o modelo **perde o contrato de saída** (devolve um JSON
+ * `{"card":{…}}` inventado em vez de `{"steps":[…]}`). Curar o catálogo
+ * para um subconjunto relevante corta a latência E ajuda o modelo a
+ * ancorar no formato. 24 cobre create-shape + cor/texto + os intents
+ * textualmente relacionados ao pedido com folga.
+ */
+declare const DEFAULT_CATALOG_MAX_ENTRIES = 24;
+/**
+ * **D-093 Fase 4** — intents **sempre** mantidos no catálogo curado
+ * (casados por `id.includes(hint)`). São as primitivas de composição:
+ * sem `create-shape` o modelo não tem como montar um "card de KPI" a
+ * partir do zero. Curtos de propósito; ampliar só com primitiva nova.
+ */
+declare const CORE_INTENT_ID_HINTS: readonly string[];
+/**
+ * Compact catalog entry fed to the model — one registered intent reduced
+ * to id + description + slot names/kinds. Kept small on purpose (token
+ * budget; the model only needs to pick an id and fill slots).
+ */
+interface LlmIntentCatalogEntry {
+    readonly id: string;
+    readonly description: string;
+    /** `{ slotName: kind }`, e.g. `{ fill: 'color', width: 'number' }`. */
+    readonly slots: Record<string, string>;
+}
+/** One resolved (validated) step of a plan — intent guaranteed to exist. */
+interface LlmResolvedStep {
+    readonly intentId: string;
+    readonly intent: NluIntent;
+    readonly slots: Record<string, unknown>;
+}
+/** The validated plan returned by {@link LlmIntentResolverService.resolvePlan}. */
+interface LlmResolvedPlan {
+    /** Steps whose `intentId` matched a registered intent (in order). */
+    readonly steps: readonly LlmResolvedStep[];
+    /** Model-reported confidence in `[0,1]` (defaults to 1 if absent). */
+    readonly confidence: number;
+    /** Raw model text (for debugging / UI "show reasoning"). */
+    readonly raw: string;
+    /** `intentId`s the model produced that do NOT exist (dropped, for telemetry). */
+    readonly dropped: readonly string[];
+}
+/** Per-call options for the resolver. */
+interface LlmResolveOptions {
+    /** Model override for THIS request (complexity routing: 3b vs 7b). */
+    readonly model?: string;
+    /** Abort the underlying request. */
+    readonly signal?: AbortSignal;
+    /** Cap generated tokens. */
+    readonly maxTokens?: number;
+}
+/** Options for {@link LlmIntentResolverService.resolveAndExecute}. */
+interface LlmExecuteOptions extends LlmResolveOptions {
+    /** Confirmation gate forwarded to {@link NaturalLanguageService.executeCandidate} (required for destructive steps). */
+    readonly confirmGate?: NluExecuteOptions['confirmGate'];
+}
+/**
+ * **D-094 — modo SEM catálogo.** Resultado de {@link
+ * LlmIntentResolverService.generateSvg}: o SVG completo extraído da resposta
+ * do modelo + o texto cru (debug / "ver resposta").
+ */
+interface LlmRawSvgResult {
+    /** Markup `<svg>…</svg>` extraído (fences/prosa removidos). `''` se nenhum. */
+    readonly svg: string;
+    /** Texto cru retornado pelo modelo (para debug / UI). */
+    readonly raw: string;
+}
+/**
+ * **D-094 — modo SEM catálogo.** Resultado de {@link
+ * LlmIntentResolverService.generateAndInsertSvg}: o SVG gerado + o desfecho
+ * da inserção no canvas (id do nó inserido ou um erro amigável).
+ */
+interface LlmRawSvgInsertResult {
+    /** `true` quando o SVG foi parseado e inserido no documento. */
+    readonly ok: boolean;
+    /** Markup SVG gerado (mesmo quando a inserção falhou — para debug). */
+    readonly svg: string;
+    /** Texto cru do modelo. */
+    readonly raw: string;
+    /** Id do nó inserido (presente só quando `ok`). */
+    readonly nodeId?: NodeId;
+    /** Avisos de saneamento do importador (scripts/handlers removidos, etc.). */
+    readonly warnings: readonly string[];
+    /** Mensagem de erro amigável quando `ok` é `false`. */
+    readonly error?: string;
+}
+/**
+ * **D-093 — `LlmIntentResolverService`** (resolver de intents via LLM).
+ *
+ * O **fallback inteligente** do NLU: quando o rule-based não resolve, o
+ * texto livre é mandado ao LLM ({@link AI_CHAT_PROVIDER}), que devolve um
+ * **plano** de comandos **já registrados** (intentId + slots). Cada passo
+ * é validado contra o registry e executado pelo pipeline seguro
+ * ({@link NaturalLanguageService.executeCandidate} — gate de destrutivos,
+ * try/catch). **O LLM nunca inventa comando** — só escolhe dos existentes,
+ * o que mantém a segurança.
+ *
+ * **Opcional por design**: se nenhum {@link AI_CHAT_PROVIDER} foi
+ * registrado, `isAvailable === false` e o app segue só com o rule-based
+ * (zero rede, specs offline). Root-scoped como o {@link NaturalLanguageService}
+ * (registry global; execução per-scope via `NluContext.injector`).
+ */
+declare class LlmIntentResolverService {
+    private readonly nlu;
+    private readonly provider;
+    /** `true` quando um provider LLM foi registrado (camada disponível). */
+    get isAvailable(): boolean;
+    /**
+     * **D-094** — modelo default do provider (o usado quando nenhum override
+     * é passado). `null` quando não há provider. Serve de fallback ao seletor
+     * de modelo da UI quando o backend não lista modelos.
+     */
+    get defaultModel(): string | null;
+    /**
+     * **D-094** — lista os modelos disponíveis no backend para o seletor de
+     * modelo da UI. Quando o provider não implementa descoberta
+     * ({@link AiChatProvider.listModels} opcional) ou não há provider,
+     * devolve `[]` — a UI cai no {@link defaultModel}. Erros de rede são
+     * propagados para o chamador decidir como degradar.
+     */
+    listModels(): Promise<readonly string[]>;
+    /**
+     * **D-095** — modelos sugeridos (curados/conhecidos) do provider, para a UI
+     * fundir com os descobertos ({@link listModels}). `[]` quando não há
+     * provider ou ele não expõe curadoria ({@link AiChatProvider.suggestedModels}
+     * é opcional). Síncrono (apenas lê um signal, sem rede).
+     */
+    suggestedModels(): readonly string[];
+    /**
+     * Catálogo compacto dos intents registrados — enviado ao modelo no
+     * system prompt. Deriva de `NaturalLanguageService.intents()`.
+     *
+     * **D-093 Fase 4 — curadoria por relevância**: quando há `text` E o
+     * total de intents excede `maxEntries`, o catálogo é **pré-filtrado**
+     * para um subconjunto relevante (primitivas core + top-K por
+     * sobreposição de tokens com o pedido). Sem `text` — ou quando o
+     * registry já cabe em `maxEntries` — devolve TODOS (comportamento
+     * legado, specs offline intactos). Isso corta o prompt de ~4095 →
+     * algumas centenas de tokens (latência) E ajuda o modelo a ancorar
+     * no contrato de saída (vide nota de {@link DEFAULT_CATALOG_MAX_ENTRIES}).
+     *
+     * @param text pedido do usuário (opcional) — base da relevância.
+     * @param opts `maxEntries` para sobrescrever o teto padrão.
+     */
+    buildCatalog(text?: string, opts?: {
+        maxEntries?: number;
+    }): readonly LlmIntentCatalogEntry[];
+    /**
+     * Pede um plano ao LLM e valida cada passo contra o registry.
+     * @throws se nenhum provider estiver registrado, ou se o modelo não
+     *   produzir JSON parseável.
+     */
+    resolvePlan(text: string, opts?: LlmResolveOptions): Promise<LlmResolvedPlan>;
+    /**
+     * Resolve o plano e **executa** cada passo pelo pipeline seguro do NLU.
+     * Passos não-destrutivos rodam direto; destrutivos exigem `confirmGate`
+     * (senão são rejeitados, como em `executeCandidate`). Cada passo vira um
+     * comando próprio no bus → **um passo de undo por etapa**.
+     */
+    resolveAndExecute(text: string, ctx: NluContext, opts?: LlmExecuteOptions): Promise<readonly NluExecuteResult[]>;
+    /**
+     * **D-094 — modo SEM catálogo.** Pede ao LLM um **SVG completo** (sem
+     * catálogo de intents, sem plano de passos) e extrai o `<svg>…</svg>` da
+     * resposta. Ao contrário de {@link resolvePlan}, **não** força
+     * `format:"json"` — a saída é markup SVG/XML cru. O `temperature:0` mantém
+     * o resultado determinístico. O chamador trata erro de rede / SVG ausente.
+     *
+     * @throws se nenhum provider estiver registrado.
+     */
+    generateSvg(text: string, opts?: LlmResolveOptions): Promise<LlmRawSvgResult>;
+    /**
+     * **D-094 — modo SEM catálogo.** Gera o SVG via {@link generateSvg},
+     * parseia/saneia com o `svgImporter` (remove `<script>`, `on*`,
+     * `javascript:` hrefs) e o **desenha no canvas** aditivamente, centralizado
+     * na página ativa — exatamente o pipeline de `File ▸ Import ▸ SVG`
+     * ({@link ImportPlacementService.placeDocumentCentered}, resolvido do
+     * **escopo do editor** via `ctx.injector`). Nunca lança por SVG inválido:
+     * devolve `{ ok:false, error }` para a UI mostrar.
+     */
+    generateAndInsertSvg(text: string, ctx: NluContext, opts?: LlmResolveOptions): Promise<LlmRawSvgInsertResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LlmIntentResolverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LlmIntentResolverService>;
+}
+/** Raw (pre-validation) step shape produced by the model. */
+interface RawPlanStep {
+    readonly intentId: string;
+    readonly slots: Record<string, unknown>;
+}
+/**
+ * Tolerant parse of the model's JSON. Strips markdown fences, slices to
+ * the outermost `{...}`, and normalizes several shapes (top-level array,
+ * single step, `{steps:[...]}`). Throws only when nothing parses.
+ */
+declare function parsePlan(raw: string): {
+    steps: RawPlanStep[];
+    confidence: number;
+};
+/**
+ * **D-094** — extract the `<svg>…</svg>` element from a model reply. Strips
+ * markdown fences (```svg / ```xml / ```html / bare ```), then slices from the
+ * first `<svg` tag to the last `</svg>`. Returns `''` when no SVG is present
+ * (the caller surfaces a friendly "no SVG returned" error). Tolerant of prose
+ * before/after, which small models sometimes emit despite the instruction.
+ */
+declare function extractSvgBlob(raw: string): string;
+
+/**
+ * **D-093 (Fase 3)** — gatilho de escalonamento para o LLM.
+ *
+ * Problema (descoberto na Fase 2): o rule-based é **guloso** com verbos
+ * de criação — "crie um card de KPI moderno com título e valor" casa
+ * `create-shape` com 90% (gera 1 retângulo default) e **não** escala,
+ * então pedidos complexos nunca chegam ao LLM.
+ *
+ * Heurística aqui: o pedido é **vago para o rule-based** quando tem
+ * conteúdo suficiente mas a maior parte dele **não é reconhecida** pelos
+ * dicionários (não é forma, cor, número/dimensão nem verbo de ação).
+ * Nesse caso o `<svge-nlu-input>` roteia direto para o LLM — que usa o
+ * texto inteiro — em vez de deixar o rule-based criar uma forma genérica.
+ *
+ * Protege os bons casos:
+ * - "criar retângulo vermelho 100x50" → 4/4 reconhecidos → NÃO vago.
+ * - "undo", "selecionar tudo" → poucos tokens → NÃO vago.
+ * - "crie um card de KPI moderno com título e valor" → só "crie"
+ *   reconhecido (1/6) → **vago** → LLM.
+ */
+/** Mínimo de tokens significativos para considerar o roteamento (frases curtas ficam no rule-based). */
+declare const VAGUE_MIN_MEANINGFUL_TOKENS = 3;
+/** Abaixo desta fração de tokens reconhecidos, o pedido é "vago". */
+declare const VAGUE_RECOGNIZED_FRACTION = 0.5;
+/**
+ * Substantivos **compostos** — coisas feitas de várias primitivas. Quando
+ * aparecem, o rule-based reduz tudo a UMA forma genérica (o `create-shape`
+ * casa "card"/"kpi" como alias de forma e gera 1 retângulo), então
+ * roteamos direto ao LLM, que sabe decompor em vários comandos.
+ * Deaccentuados/lowercase (forma do tokenizer).
+ */
+declare const COMPOSITE_KEYWORDS: ReadonlySet<string>;
+/**
+ * Decide se `text` deve pular o rule-based e ir direto ao LLM.
+ * Pure function — sem efeitos colaterais, testável offline.
+ *
+ * Vago quando QUALQUER:
+ * 1. contém um substantivo composto ({@link COMPOSITE_KEYWORDS}) — ex.:
+ *    "card", "dashboard", "organograma" (o rule-based só faria 1 forma); OU
+ * 2. tem conteúdo suficiente mas a maioria dos tokens **não é reconhecida**
+ *    pelos dicionários (forma/cor/número/ação) — ex.: "casa com telhado e
+ *    porta".
+ */
+declare function isVagueForRuleBased(text: string): boolean;
+
+export { ACTION_DICTIONARY, ACTION_DICTIONARY_EN, ACTION_DICTIONARY_PT, ACTION_KEYS, AI_CHAT_PROVIDER, COLOR_DICTIONARY, COLOR_DICTIONARY_EN, COLOR_DICTIONARY_PT, COLOR_KEYS, COMPOSITE_KEYWORDS, CORE_INTENT_ID_HINTS, DEFAULT_CATALOG_MAX_ENTRIES, DEFAULT_OLLAMA_BASE_URL, DEFAULT_OLLAMA_MODEL, DEFAULT_OLLAMA_MODELS, HEX_COLOR_RE, LIGHTNESS_MODIFIERS, LIGHTNESS_MULTIPLIERS, LlmIntentResolverService, NUMBER_WORDS, NaturalLanguageService, NluDictionaryRegistry, OllamaChatProvider, SHAPE_DICTIONARY, SHAPE_DICTIONARY_EN, SHAPE_DICTIONARY_PT, SHAPE_KEYS, STOPWORDS, STOPWORDS_EN, STOPWORDS_PT, VAGUE_MIN_MEANINGFUL_TOKENS, VAGUE_RECOGNIZED_FRACTION, VOICE_WHISPER_PROVIDER, adaptiveMaxDistance, adjustHexLightness, bestMatch, builtinNluPlugin, darkenHex, deaccent, detectLanguage, discoverMenuIntents, discoverMenuIntentsReactive, extractSlots, extractSvgBlob, fuzzyMatchAll, fuzzyMatchAny, fuzzyMatchToken, hexToRgb, hslToRgb, isStopword, isVagueForRuleBased, levenshtein, lightenHex, menuContributionToIntent, normalize, parseColorPhrase, parseColorToken, parseDimensionToken, parseHslFunction, parseNumberToken, parsePlan, parseRgbFunction, provideOllamaChat, resolveActionCanonical, resolveColorName, resolveNumberWord, resolveShapeKind, rgbToHsl, tokenize, tokenizeWithoutStopwords };
+export type { ActionCanonical, AiChatMessage, AiChatOptions, AiChatProvider, AiChatRole, ColorPhraseMatch, DiscoverMenuIntentsReactiveResult, DiscoverMenuIntentsResult, ExtractContext, ExtractedSlots, FuzzyMatch, LanguageDetectResult, LlmExecuteOptions, LlmIntentCatalogEntry, LlmRawSvgInsertResult, LlmRawSvgResult, LlmResolveOptions, LlmResolvedPlan, LlmResolvedStep, NluCandidate, NluContext, NluExecuteOptions, NluExecuteResult, NluIntent, NluLanguage, NluMatchReason, NluParseOptions, NluShapeKind, NluSlotSchema, OllamaChatConfig, VoiceEngine, VoiceProvider };