@mosaicoo/svg-engine 0.1.0

package/fesm2022/mosaicoo-svg-engine.mjs

@@ -0,0 +1 @@
+const E="0.1.0";export{E as SVG_ENGINE_VERSION};

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@mosaicoo/svg-engine",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Headless-first, plugin-extensible SVG editor library for Angular v21+. Render, manipulate and optimize SVG inside any Angular app — 9 secondary entry points (core/render/io/optimize/edit/ui + ai/nlu + ai/nlu-ui + ai/nlu-voice-wasm), Material UI is opt-in and local Whisper voice is opt-in.",
+  "keywords": [
+    "svg",
+    "svg-editor",
+    "svg-renderer",
+    "svg-optimizer",
+    "vector",
+    "vector-graphics",
+    "angular",
+    "angular-library",
+    "ng-packagr",
+    "headless",
+    "plugin",
+    "pathfinder",
+    "anchor-editor"
+  ],
+  "author": "Mosaicoo",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/mosaicoo/svg-engine#readme",
+  "bugs": {
+    "url": "https://github.com/mosaicoo/svg-engine/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mosaicoo/svg-engine.git",
+    "directory": "projects/svg-engine"
+  },
+  "peerDependencies": {
+    "@angular/common": "^21.2.0",
+    "@angular/core": "^21.2.0",
+    "@angular/material": "^21.2.0",
+    "@angular/cdk": "^21.2.0",
+    "@huggingface/transformers": "^4.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@angular/material": {
+      "optional": true
+    },
+    "@angular/cdk": {
+      "optional": true
+    },
+    "@huggingface/transformers": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "polygon-clipping": "^0.15.7",
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/mosaicoo-svg-engine.mjs",
+  "typings": "types/mosaicoo-svg-engine.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/mosaicoo-svg-engine.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine.mjs"
+    },
+    "./ai/nlu": {
+      "types": "./types/mosaicoo-svg-engine-ai-nlu.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-ai-nlu.mjs"
+    },
+    "./ai/nlu-ui": {
+      "types": "./types/mosaicoo-svg-engine-ai-nlu-ui.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-ai-nlu-ui.mjs"
+    },
+    "./ai/nlu-voice-wasm": {
+      "types": "./types/mosaicoo-svg-engine-ai-nlu-voice-wasm.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-ai-nlu-voice-wasm.mjs"
+    },
+    "./core": {
+      "types": "./types/mosaicoo-svg-engine-core.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-core.mjs"
+    },
+    "./edit": {
+      "types": "./types/mosaicoo-svg-engine-edit.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-edit.mjs"
+    },
+    "./io": {
+      "types": "./types/mosaicoo-svg-engine-io.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-io.mjs"
+    },
+    "./optimize": {
+      "types": "./types/mosaicoo-svg-engine-optimize.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-optimize.mjs"
+    },
+    "./render": {
+      "types": "./types/mosaicoo-svg-engine-render.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-render.mjs"
+    },
+    "./ui": {
+      "types": "./types/mosaicoo-svg-engine-ui.d.ts",
+      "default": "./fesm2022/mosaicoo-svg-engine-ui.mjs"
+    }
+  },
+  "type": "module"
+}

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

@@ -0,0 +1,416 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { VoiceEngine, NluCandidate, NluExecuteResult, NaturalLanguageService, LlmIntentResolverService } from '@mosaicoo/svg-engine/ai/nlu';
+
+/**
+ * **`VoiceEngineService`** — orquestrador de voz com engine
+ * **selecionável pelo usuário** (D-046 voz híbrida).
+ *
+ * Expõe a MESMA surface de um {@link VoiceProvider}
+ * (`isSupported`/`listening`/`lastError`/`listen`/`stop`) para o
+ * `<svge-nlu-input>` consumir de forma transparente, mas internamente
+ * delega para:
+ * - **Web Speech** ({@link VoiceRecognitionService}) — sempre presente.
+ * - **Whisper local** (via {@link VOICE_WHISPER_PROVIDER}) — opcional,
+ *   só quando o app chamou `provideWhisperVoiceEngine()`.
+ *
+ * **Modos** ({@link VoiceEngine}):
+ * - `'web-speech'`: usa só a Web Speech API.
+ * - `'whisper'`: usa só o Whisper local (offline).
+ * - `'auto'`: tenta Web Speech e, em **falha** (ex.: `network`),
+ *   cai automaticamente para o Whisper. Só fica disponível quando as
+ *   duas engines existem.
+ *
+ * O `lastError` é **próprio** do orquestrador (não espelha os providers
+ * diretamente): zera no início de cada `listen()` e só é setado quando
+ * a tentativa realmente falha — assim um erro `network` do Web Speech
+ * não fica "preso" na UI após um fallback Whisper bem-sucedido.
+ */
+declare class VoiceEngineService {
+    private readonly webSpeech;
+    /** Provider Whisper, se o app registrou; senão `null`. */
+    private readonly whisper;
+    private readonly _engine;
+    /** Engine atualmente selecionada. */
+    readonly engine: Signal<VoiceEngine>;
+    /** `true` se a voz local (Whisper) está registrada. */
+    readonly whisperAvailable: Signal<boolean>;
+    /**
+     * Engines disponíveis (suportadas no ambiente atual). `'auto'` só
+     * aparece quando as duas engines básicas existem. A UI mostra o
+     * seletor apenas quando há mais de uma opção.
+     */
+    readonly availableEngines: Signal<readonly VoiceEngine[]>;
+    /** `false` quando nenhuma engine está disponível (UI esconde o mic). */
+    readonly isSupported: Signal<boolean>;
+    /** `true` enquanto qualquer provider está capturando/processando. */
+    readonly listening: Signal<boolean>;
+    /** `true` durante o carregamento do modelo Whisper (primeira vez). */
+    readonly modelLoading: Signal<boolean>;
+    private readonly _lastError;
+    /** Último erro do orquestrador (limpo a cada `listen` bem-sucedido). */
+    readonly lastError: Signal<string | null>;
+    constructor();
+    /** Troca a engine ativa. Ignora valores não disponíveis no ambiente. */
+    setEngine(engine: VoiceEngine): void;
+    /**
+     * Inicia a captura na engine selecionada e resolve com a transcrição.
+     * Em `'auto'`, tenta Web Speech e cai para o Whisper se falhar.
+     */
+    listen(lang?: string, options?: {
+        readonly timeoutMs?: number;
+    }): Promise<string>;
+    /** Encerra a captura ativa em ambos os providers (seguro se inativos). */
+    stop(): void;
+    /** Executa um provider único, propagando o erro para `_lastError`. */
+    private runProvider;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VoiceEngineService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<VoiceEngineService>;
+}
+
+/** Opção de idioma de voz exibida no seletor. */
+interface VoiceLanguageOption {
+    /** BCP-47 (Web Speech usa direto; Whisper mapeia p/ nome do idioma). */
+    readonly code: string;
+    /** Rótulo completo no menu. */
+    readonly label: string;
+    /** Rótulo curto (chip/tooltip). */
+    readonly short: string;
+}
+/**
+ * **`<svge-nlu-input>`** — D-046 Fase 1 UI surface.
+ *
+ * Input textual + voice button para enviar comandos em linguagem
+ * natural ao {@link NaturalLanguageService}. Mostra:
+ *
+ * - Campo de texto Material outlined + prefix icon (smart_toy)
+ * - **Mic button** (Web Speech API) com pulse animation enquanto grava
+ * - **Run button** (Enter também dispara)
+ * - **Live preview** do top candidate (label + confidence% + bar colorida)
+ * - **Status** do último execute (success / rejeição com motivo humano)
+ * - **Botão "Confirmar"** quando rejection é destructive ou low-confidence
+ *   — usuário aprova explicitamente em vez de ficar travado
+ * - **Lista de alternativas** clicável (cada click respeita threshold +
+ *   destructive via `nlu.executeCandidate`)
+ *
+ * **Por que `window.confirm` default e não Material dialog**: zero
+ * dependência circular `nlu-ui → ui` (D-017-style isolation entre
+ * camadas AI e dialogs Material). Consumer pode override via input
+ * `confirmGate` se quiser dialog próprio.
+ *
+ * **Multi-editor (D-042/D-043)**: passa `{ injector: this.hostInjector }`
+ * para `executeCandidate`/`execute` — handlers resolvem services do
+ * scope ativo automaticamente.
+ *
+ * **Acessibilidade**:
+ * - Input ARIA-described com hint do top candidate
+ * - Mic button: `aria-pressed` reativo
+ * - Lista de alternatives: `role="listbox"` + `role="option"` + `aria-selected="false"`
+ * - Status com `aria-live="polite"`
+ */
+declare class SvgeNluInput {
+    /** Label do input (Material outline). Default em PT. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Placeholder textual. Default exemplo PT. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /**
+     * BCP-47 language tag pra voice recognition. Default `pt-BR`.
+     *
+     * **D-046 review-10 (M14)**: quando `autoDetectLanguage = true`,
+     * o componente sobreescreve esse default usando `detectLanguage(text)`
+     * (PT/EN). Override manual deste input sempre tem prioridade.
+     */
+    readonly voiceLang: _angular_core.InputSignal<string>;
+    /**
+     * **D-046 review-10 (M14)**: auto-detecta idioma do input via
+     * dicionários PT/EN (hits count). Quando `true`, passa o resultado
+     * pra `voice.listen()` em vez de `voiceLang()` estático.
+     *
+     * Útil pra apps que aceitam PT E EN sem o user trocar config manual.
+     */
+    readonly autoDetectLanguage: _angular_core.InputSignal<boolean>;
+    /**
+     * **D-046 review-10 (M5)**: debounce em ms antes de rodar `parse()`.
+     * Default 0 (sem debounce — mantém comportamento Fase 1).
+     * Recomendado `150` pra voice input rápido (~6 keystrokes/s).
+     * Acima de 300 fica perceptível pro user.
+     */
+    readonly parseDebounceMs: _angular_core.InputSignal<number>;
+    /**
+     * Confidence mínima pra auto-execute. Abaixo disso, o componente
+     * **não** dispara automaticamente — mostra "Confirmar" pra usuário
+     * aprovar explicitamente, OU rejeita se gate não aprovar.
+     */
+    readonly autoExecuteThreshold: _angular_core.InputSignal<number>;
+    /**
+     * Gate de confirmação customizado. Quando ausente (default), usa
+     * **`window.confirm`** nativo — funciona sem dependência extra, é
+     * universal, e dispensa abrir Material dialog (privacy + zero
+     * coupling com `svg-engine/ui`).
+     *
+     * Override pra integrar com Material dialog próprio ou tela custom:
+     * ```ts
+     * <svge-nlu-input [confirmGate]="myDialogGate" />
+     * ```
+     *
+     * O gate recebe o candidate (com `intent.id`, `intent.destructive`,
+     * `confidence`, `slots`) e retorna `boolean | Promise<boolean>`.
+     */
+    readonly confirmGate: _angular_core.InputSignal<((candidate: NluCandidate) => boolean | Promise<boolean>) | null>;
+    /**
+     * **D-093** — habilita o **fallback LLM**: quando o NLU rule-based não
+     * reconhece o pedido (`no-match`), escala para o
+     * {@link LlmIntentResolverService}, que pede um plano de comandos ao LLM
+     * e o executa pelo mesmo pipeline seguro. Só dispara se um provider LLM
+     * estiver registrado (`AI_CHAT_PROVIDER`); senão é no-op. Default `true`.
+     */
+    readonly enableLlmFallback: _angular_core.InputSignal<boolean>;
+    /**
+     * **D-093** — modelo a usar no fallback LLM (roteamento por
+     * complexidade). `null` = usa o default do provider. O consumer pode
+     * passar `qwen2.5:7b` para pedidos pesados, por exemplo.
+     */
+    readonly llmModel: _angular_core.InputSignal<string | null>;
+    /** Evento emitido após cada execute (sucesso ou rejeição). */
+    readonly executed: _angular_core.OutputEmitterRef<NluExecuteResult>;
+    protected readonly nlu: NaturalLanguageService;
+    protected readonly llm: LlmIntentResolverService;
+    protected readonly voice: VoiceEngineService;
+    private readonly hostInjector;
+    private readonly textInputRef;
+    protected readonly text: _angular_core.WritableSignal<string>;
+    /**
+     * **D-046 review-10 (M5)**: signal debouncado pra reduzir parse rate.
+     * Quando `parseDebounceMs=0`, sempre igual a `text()`. Caso contrário,
+     * só atualiza após o delay sem mudanças (typing burst absorve).
+     */
+    protected readonly debouncedText: _angular_core.WritableSignal<string>;
+    private debounceHandle;
+    protected readonly lastResult: _angular_core.WritableSignal<NluExecuteResult | null>;
+    /** **D-093** — `true` enquanto o fallback LLM está interpretando (spinner). */
+    protected readonly llmThinking: _angular_core.WritableSignal<boolean>;
+    /** **D-093** — mensagem de erro do fallback LLM (rede / JSON inválido / sem comandos). */
+    protected readonly llmError: _angular_core.WritableSignal<string | null>;
+    /**
+     * **D-094 — modo de geração do LLM.** `'catalog'` (default) escala para o
+     * resolver de **intents** (o LLM devolve um plano de comandos já
+     * registrados); `'raw-svg'` pede um **SVG completo** e o desenha no canvas
+     * (sem catálogo). Trocável pelo usuário no menu de configuração da IA.
+     */
+    protected readonly llmMode: _angular_core.WritableSignal<"catalog" | "raw-svg">;
+    /**
+     * **D-094 — modelo escolhido pelo usuário** no seletor (`null` = usa o
+     * default do provider). Tem prioridade sobre o input {@link llmModel}.
+     */
+    protected readonly selectedModel: _angular_core.WritableSignal<string | null>;
+    /** **D-094 — modelos disponíveis** descobertos no backend (Ollama /api/tags). */
+    protected readonly availableModels: _angular_core.WritableSignal<readonly string[]>;
+    /**
+     * **D-094/D-095** — opções do seletor de modelo: funde os modelos
+     * **descobertos** ao vivo (`/api/tags`, instalados de fato) com os
+     * **curados** ({@link LlmIntentResolverService.suggestedModels} — ex.: os
+     * `qwen2.5-coder`) e garante o default do provider na lista, tudo
+     * deduplicado. Os curados servem de fallback quando a descoberta falha.
+     */
+    protected readonly modelOptions: _angular_core.Signal<readonly string[]>;
+    /**
+     * **D-094** — modelo que **de fato** será usado na próxima chamada:
+     * seleção do usuário › input `llmModel` › default do provider. Usado no
+     * seletor (checkmark) e como rótulo no tooltip.
+     */
+    protected readonly effectiveModel: _angular_core.Signal<string | null>;
+    constructor();
+    /**
+     * **D-094** — carrega a lista de modelos do backend (Ollama `/api/tags`)
+     * para o seletor. Best-effort: backend offline ou sem suporte a listagem
+     * mantém a lista vazia (o seletor cai no default do provider).
+     */
+    private loadModels;
+    /** **D-094** — troca o modo de geração do LLM (catálogo ↔ SVG livre). */
+    protected setLlmMode(mode: 'catalog' | 'raw-svg'): void;
+    /** **D-094** — seleciona o modelo do seletor (override do default). */
+    protected selectModel(model: string): void;
+    /**
+     * **D-094** — modelo a enviar na próxima chamada LLM: seleção do usuário ›
+     * input `llmModel` › `undefined` (provider usa seu default).
+     */
+    private requestModel;
+    /**
+     * Candidates ordenados por confidence — recomputa quando
+     * `debouncedText` muda OU quando o registry de intents muda.
+     */
+    protected readonly candidates: _angular_core.Signal<readonly NluCandidate[]>;
+    /**
+     * **D-046 review-10 (M14)**: idioma detectado do input (PT/EN/unknown).
+     * Quando `autoDetectLanguage = true`, este valor sobreescreve `voiceLang()`
+     * default pra escolher o engine STT do browser correto.
+     */
+    protected readonly detectedLanguage: _angular_core.Signal<"unknown" | "pt" | "en">;
+    /**
+     * Idioma de voz selecionado (BCP-47). Default = **locale do navegador**
+     * (normalizado p/ PT-BR/EN-US/ES-ES), trocável pelo usuário no seletor
+     * de idioma. Serve às duas engines: a Web Speech usa o BCP-47 direto; o
+     * Whisper mapeia para o nome do idioma (pt-BR → "portuguese").
+     */
+    protected readonly selectedLanguage: _angular_core.WritableSignal<string>;
+    /** Opções do seletor de idioma. */
+    protected readonly languages: readonly VoiceLanguageOption[];
+    /**
+     * Resolve BCP-47 efetivo pro `voice.listen(lang)`: o idioma do seletor.
+     * Quando `autoDetectLanguage = true`, o idioma detectado do **texto
+     * digitado** (PT/EN) tem prioridade sobre a seleção manual.
+     */
+    protected readonly effectiveVoiceLang: _angular_core.Signal<string>;
+    protected readonly topCandidate: _angular_core.Signal<NluCandidate | null>;
+    protected readonly alternatives: _angular_core.Signal<readonly NluCandidate[]>;
+    /**
+     * Mensagem **acionável** pra erro do Web Speech API. Mapeia os codes
+     * crus (`'network'`, `'not-allowed'`, `'no-speech'`, `'audio-capture'`,
+     * `'service-not-allowed'`) pra texto humano em PT com o passo concreto
+     * que o usuário pode tomar pra resolver. Retorna `null` quando não
+     * deve mostrar nada (sem erro OU erro `'aborted'` que é silencioso).
+     *
+     * **Por que `'network'` é comum no Chrome**: o Web Speech API delega
+     * o reconhecimento a servidores Google STT — sem internet, com
+     * firewall corporativo ou com bloqueador (uBlock/Brave Shields)
+     * filtrando `*.google.com`, o handshake falha e o navegador dispara
+     * esse erro. Não é bug do app — é dependência arquitetural do
+     * Web Speech API spec ao backend STT do vendor.
+     */
+    protected readonly voiceErrorMessage: _angular_core.Signal<string | null>;
+    /** Troca o idioma de voz (seletor) e persiste a escolha. */
+    protected setLanguage(code: string): void;
+    /** Rótulo curto do idioma atual (chip do seletor). */
+    protected languageShort(code: string): string;
+    /** Rótulo humano para cada engine de voz. */
+    protected engineLabel(engine: VoiceEngine): string;
+    /** Ícone Material para cada engine de voz. */
+    protected engineIcon(engine: VoiceEngine): string;
+    /** Tooltip do botão de microfone (reflete carregamento/gravação). */
+    protected micTooltip(): string;
+    /**
+     * Input handler — atualiza o signal a partir do valor nativo. Não
+     * usamos `[value]` binding (que conflita com o controle interno do
+     * MatInput em digitação rápida); em vez disso lemos do input direto
+     * e setamos programaticamente via `setTextProgrammatically` quando
+     * preciso (voice transcript, limpar pós-execute).
+     */
+    protected onInput(value: string): void;
+    /**
+     * Seta o valor do input programaticamente (voice transcript, clear
+     * pós-execute). Atualiza o signal E o input element value — o input
+     * nativo não escuta mudanças de signal sozinho.
+     *
+     * **D-046 review-10**: também atualiza `debouncedText` IMEDIATO
+     * (sem debounce) — caller programático sabe que o valor é final.
+     */
+    private setTextProgrammatically;
+    protected runNow(): Promise<void>;
+    /**
+     * **D-093** — fallback LLM. Pede um plano de comandos ao
+     * {@link LlmIntentResolverService} e o executa pelo mesmo pipeline
+     * seguro. Mostra spinner enquanto interpreta (pode levar segundos no
+     * hardware local) e mensagem amigável em caso de erro/sem-comandos.
+     * Não limpa o input em falha (o usuário pode reformular).
+     */
+    private escalateToLlm;
+    /**
+     * **D-094 — modo SEM catálogo.** Pede um SVG completo ao
+     * {@link LlmIntentResolverService.generateAndInsertSvg}, que o parseia,
+     * saneia e desenha no canvas. Em sucesso limpa o input; em falha mostra o
+     * erro amigável do resolver. Erros de rede sobem para o `catch` de
+     * {@link escalateToLlm}.
+     */
+    private escalateRawSvg;
+    /**
+     * **D-093 Fase 3** — escape hatch explícito: manda o texto **direto**
+     * ao LLM, ignorando o rule-based. Útil quando o usuário sabe que quer a
+     * IA (ex.: composição complexa) independente do que o rule-based acharia.
+     */
+    protected askAi(): Promise<void>;
+    /**
+     * Executa um candidate específico (clique na lista de alternativas)
+     * — usa `nlu.executeCandidate` que aplica gate + threshold +
+     * destructive check, em vez de chamar `intent.execute` direto
+     * (que bypassaria toda a defesa).
+     */
+    protected execCandidate(cand: NluCandidate): Promise<void>;
+    /**
+     * Força a execução do top candidate **após** o usuário clicar
+     * "Confirmar" — passa um gate `() => true` overridand a rejeição
+     * `'destructive-no-gate'` / `'below-threshold'` anterior.
+     */
+    protected forceExecute(rejected: NluExecuteResult): Promise<void>;
+    /**
+     * `true` quando o último resultado merece um botão "Confirmar" na
+     * UI: usuário escolheu rodar e bateu numa proteção (destrutivo sem
+     * gate, ou confidence baixa sem gate), mas há candidate concreto
+     * pra forçar execução manualmente.
+     */
+    protected canForceExecute(result: NluExecuteResult): boolean;
+    protected toggleVoice(): Promise<void>;
+    /**
+     * Texto humano pra exibir do candidate. Prioridade:
+     * 1. `intent.description` (quando explícita)
+     * 2. Keywords joined (mais legível que reverse-DNS id)
+     * 3. `intent.id` (último recurso)
+     */
+    protected describeIntent(c: NluCandidate): string;
+    protected confidencePercent(c: NluCandidate): number;
+    protected describeRejection(result: NluExecuteResult): string;
+    /**
+     * Monta as `NluExecuteOptions` consolidadas: thresholds + gate.
+     * Quando o consumer não passou `confirmGate` via input, usa
+     * `window.confirm` como default — universal, zero dep.
+     */
+    private executeOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvgeNluInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SvgeNluInput, "svge-nlu-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "voiceLang": { "alias": "voiceLang"; "required": false; "isSignal": true; }; "autoDetectLanguage": { "alias": "autoDetectLanguage"; "required": false; "isSignal": true; }; "parseDebounceMs": { "alias": "parseDebounceMs"; "required": false; "isSignal": true; }; "autoExecuteThreshold": { "alias": "autoExecuteThreshold"; "required": false; "isSignal": true; }; "confirmGate": { "alias": "confirmGate"; "required": false; "isSignal": true; }; "enableLlmFallback": { "alias": "enableLlmFallback"; "required": false; "isSignal": true; }; "llmModel": { "alias": "llmModel"; "required": false; "isSignal": true; }; }, { "executed": "executed"; }, never, never, true, never>;
+}
+
+declare class VoiceRecognitionService {
+    /** Quando `false`, a UI deve esconder/desabilitar o botão de voz. */
+    readonly isSupported: Signal<boolean>;
+    private readonly _listening;
+    /** `true` enquanto o microfone está capturando. */
+    readonly listening: Signal<boolean>;
+    private readonly _lastError;
+    /**
+     * Último erro do recognizer (`'no-speech'`, `'aborted'`,
+     * `'not-allowed'`, etc.). Reseta no próximo `start()`.
+     */
+    readonly lastError: Signal<string | null>;
+    private activeRec;
+    /**
+     * Default timeout pra `listen()` (D-046 review-10).
+     * 30 segundos cobre comandos longos sem deixar Promise pendurada
+     * indefinidamente quando o recognizer entra em estado patológico
+     * (tab em background, perda de conexão, browser sem disparar onend).
+     */
+    static readonly DEFAULT_LISTEN_TIMEOUT_MS = 30000;
+    /**
+     * Default do **watchdog de silêncio** (VAD) — encerra a captura
+     * `DEFAULT_SILENCE_MS` ms após a última palavra reconhecida, espelhando
+     * o auto-stop do provider Whisper local. A Web Speech API não tem
+     * config nativa de endpointing; emulamos via `interimResults`.
+     */
+    static readonly DEFAULT_SILENCE_MS = 1000;
+    /**
+     * Inicia a captura. Resolve com a transcrição final quando o
+     * recognizer terminar. Rejeita em erro, em timeout ou se chamado sem suporte.
+     *
+     * @param lang BCP-47 language tag (default `pt-BR`)
+     * @param options.timeoutMs timeout em ms (default 30000). Após
+     *   expirar, aborta o recognizer e rejeita com `'timeout'`.
+     */
+    listen(lang?: string, options?: {
+        readonly timeoutMs?: number;
+        readonly silenceMs?: number;
+    }): Promise<string>;
+    /** Aborta a captura ativa, se houver. */
+    stop(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VoiceRecognitionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<VoiceRecognitionService>;
+}
+
+export { SvgeNluInput, VoiceEngineService, VoiceRecognitionService };