speechready 0.0.0-stage → 0.1.0

package/dist/lexicon.js

@@ -0,0 +1,131 @@
+/** One pronunciation lexicon, applied in the pipeline and exported to each vendor's format.
+ *
+ * An entry says how a word is pronounced in one of three ways:
+ * - `ipa`: an IPA transcription, rendered as a phoneme tag where the provider
+ *   accepts one (Azure, Google, Polly) and exported to lexicon files;
+ * - `say`: a respelling or alias ("engine X", "sequel") that replaces the word in
+ *   the text, which works on every provider;
+ * - `spell: true`: the word is read letter by letter.
+ *
+ * When a provider cannot take a phoneme tag, an entry falls back to `say`, then
+ * to `spell`, then leaves the word alone.
+ */
+import { SENTINEL_CLOSE, SENTINEL_OPEN, intent } from "./intents.js";
+import { W, escapeRe, escapeXml, re, sub } from "./util.js";
+export function entry(e) {
+    return { ipa: "", say: "", spell: false, case_sensitive: false, ...e };
+}
+function entryIntent(e, matched) {
+    if (e.spell && !e.ipa && !e.say)
+        return intent("spell", { text: matched });
+    return intent("phoneme", { text: matched, ipa: e.ipa, say: e.say });
+}
+export class Lexicon {
+    entries;
+    locale;
+    constructor(entries = [], locale = "en-US") {
+        this.entries = entries.map(entry);
+        this.locale = locale;
+    }
+    // --- construction ---------------------------------------------------------------
+    static fromEntries(entries, locale = "en-US") {
+        return new Lexicon(entries, locale);
+    }
+    /** Build from a parsed lexicon document (`{locale, entries}`), e.g. `JSON.parse` of a lexicon file. */
+    static fromObject(data) {
+        return new Lexicon(data.entries ?? [], data.locale ?? "en-US");
+    }
+    /** Read a `.json` lexicon file, or a `.yaml` one when the optional `yaml` package is installed. Node only. */
+    static async load(path) {
+        const fs = await import("node:fs/promises");
+        const text = await fs.readFile(path, "utf-8");
+        if (/\.ya?ml$/i.test(path)) {
+            let yaml;
+            try {
+                yaml = (await import("yaml"));
+            }
+            catch {
+                throw new Error("reading a YAML lexicon needs the `yaml` package (npm install yaml); JSON lexicons need nothing");
+            }
+            return Lexicon.fromObject(yaml.parse(text));
+        }
+        return Lexicon.fromObject(JSON.parse(text));
+    }
+    toObject() {
+        return {
+            locale: this.locale,
+            entries: this.entries.map((e) => {
+                const out = {};
+                for (const [k, v] of Object.entries({ word: e.word, ipa: e.ipa, say: e.say, spell: e.spell, case_sensitive: e.case_sensitive })) {
+                    if (v)
+                        out[k] = v;
+                }
+                return out;
+            }),
+        };
+    }
+    // --- applying to text ------------------------------------------------------------
+    /** Replace every lexicon word in `text` with an intent sentinel; appends to `intents`. */
+    apply(text, intents) {
+        if (!this.entries.length)
+            return text;
+        let work = text;
+        const ordered = [...this.entries].sort((a, b) => b.word.length - a.word.length);
+        for (const e of ordered) {
+            const flags = e.case_sensitive ? "" : "i";
+            const pattern = re(`(?<![${W}${SENTINEL_OPEN}${SENTINEL_CLOSE}])${escapeRe(e.word)}(?![${W}])`, flags);
+            work = sub(pattern, work, (m) => {
+                intents.push(entryIntent(e, m[0]));
+                return `${SENTINEL_OPEN}${intents.length - 1}${SENTINEL_CLOSE}`;
+            });
+        }
+        return work;
+    }
+    // --- export ----------------------------------------------------------------------------
+    /** Pronunciation Lexicon Specification XML, accepted by ElevenLabs, Azure and Amazon Polly. */
+    toPls(alphabet = "ipa") {
+        const lines = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            `<lexicon version="1.0" xmlns="http://www.w3.org/2005/01/pronunciation-lexicon" alphabet="${alphabet}" xml:lang="${this.locale}">`,
+        ];
+        for (const e of this.entries) {
+            lines.push("  <lexeme>");
+            lines.push(`    <grapheme>${escapeXml(e.word)}</grapheme>`);
+            if (e.ipa)
+                lines.push(`    <phoneme>${escapeXml(e.ipa)}</phoneme>`);
+            else if (e.say)
+                lines.push(`    <alias>${escapeXml(e.say)}</alias>`);
+            else if (e.spell)
+                lines.push(`    <alias>${escapeXml(Array.from(e.word).join(" "))}</alias>`);
+            lines.push("  </lexeme>");
+        }
+        lines.push("</lexicon>");
+        return lines.join("\n") + "\n";
+    }
+    /** Google Cloud TTS custom pronunciations (v1beta1 `customPronunciations`). IPA entries only. */
+    toGoogleJson() {
+        const items = this.entries
+            .filter((e) => e.ipa)
+            .map((e) => ({ phrase: e.word, phoneticEncoding: "PHONETIC_ENCODING_IPA", pronunciation: e.ipa }));
+        return JSON.stringify({ pronunciations: items }, null, 2) + "\n";
+    }
+    toJson() {
+        return JSON.stringify(this.toObject(), null, 2) + "\n";
+    }
+    /** The upload file for a provider profile, or null when the provider takes no lexicon. */
+    exportFor(profile) {
+        if (profile.lexiconFormat === "none")
+            return null;
+        return this.export(profile.lexiconFormat, profile.lexiconAlphabet);
+    }
+    /** `pls`, `google`, or `json`. */
+    export(fmt, alphabet = "ipa") {
+        if (fmt === "pls")
+            return this.toPls(alphabet);
+        if (fmt === "google")
+            return this.toGoogleJson();
+        if (fmt === "json")
+            return this.toJson();
+        throw new Error(`unknown lexicon format ${JSON.stringify(fmt)}; use pls, google or json`);
+    }
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,34 @@
+/** The pipeline: clean -> verbalize -> compile -> chunk, with a change log. */
+import { Change } from "./changes.js";
+import { Options } from "./clean.js";
+import { EntryInput, Lexicon } from "./lexicon.js";
+import { Profile } from "./profiles/index.js";
+import "./verbalize/en.js";
+import "./verbalize/tr.js";
+export interface Prepared {
+    /** The full compiled text. */
+    text: string;
+    /** The same text split under the model's request limit. */
+    chunks: string[];
+    /** Every rewrite: rule, before, after, note. */
+    changes: Change[];
+    profile: Profile;
+    locale: string;
+}
+export interface PrepareInit {
+    provider?: string | null;
+    model?: string | null;
+    /** A profile picked directly; overrides provider and model. */
+    profile?: Profile | null;
+    locale?: string;
+    /** Overrides the profile's request limit (null = no limit, undefined = the profile's). */
+    limit?: number | null;
+    options?: Partial<Options> | null;
+    /** A Lexicon, or its entries; its words are pronounced as it says. */
+    lexicon?: Lexicon | EntryInput[] | null;
+}
+/** Prepare `text` for the given provider and model.
+ *
+ * Returns the full compiled text, the request-sized chunks, and every change made.
+ */
+export declare function prepare(text: string, init?: PrepareInit): Prepared;

package/dist/pipeline.js

@@ -0,0 +1,49 @@
+/** The pipeline: clean -> verbalize -> compile -> chunk, with a change log. */
+import { Recorder } from "./changes.js";
+import { pack, splitSentences } from "./chunk.js";
+import { clean } from "./clean.js";
+import { compileText } from "./compile.js";
+import { extract, sentinelPattern } from "./intents.js";
+import { Lexicon } from "./lexicon.js";
+import { resolveProfile } from "./profiles/index.js";
+import { sub } from "./util.js";
+import { verbalize } from "./verbalize/index.js";
+import "./verbalize/en.js";
+import "./verbalize/tr.js";
+/** Prepare `text` for the given provider and model.
+ *
+ * Returns the full compiled text, the request-sized chunks, and every change made.
+ */
+export function prepare(text, init = {}) {
+    const locale = init.locale ?? "en-US";
+    const lex = Array.isArray(init.lexicon) ? Lexicon.fromEntries(init.lexicon, locale) : init.lexicon ?? null;
+    const prof = init.profile ?? resolveProfile(init.provider ?? null, init.model ?? null);
+    const rec = new Recorder();
+    let [work, intents] = extract(text);
+    work = clean(work, init.options, rec, locale);
+    [work, intents] = extract(work, intents);
+    if (lex) {
+        const before = work;
+        work = lex.apply(work, intents);
+        rec.add("lexicon", "lexicon.apply", before, work, "lexicon words marked for pronunciation");
+    }
+    work = verbalize(work, locale, rec, init.options);
+    work = compileText(work, intents, prof, rec);
+    const maxSize = init.limit !== undefined ? init.limit : prof.limitFor(init.model ?? null);
+    const sentences = splitSentences(work, locale);
+    const chunks = pack(sentences, maxSize, prof.limitUnit, " ");
+    return { text: work, chunks, changes: readable(rec.changes, intents), profile: prof, locale };
+}
+function intentTag(intent) {
+    if (intent.kind === "pause")
+        return `[pause ${intent.ms}ms]`;
+    if (intent.kind === "phoneme")
+        return `[ipa ${intent.text} ${intent.ipa || intent.say}]`;
+    return `[${intent.kind} ${intent.text}]`;
+}
+/** Show intents in the change log as the tags the developer wrote, not as sentinels. */
+function readable(changes, intents) {
+    const pattern = sentinelPattern();
+    const fix = (text) => sub(pattern, text, (m) => intentTag(intents[parseInt(m[1], 10)]));
+    return changes.map((c) => ({ ...c, before: fix(c.before), after: fix(c.after) }));
+}

package/dist/profiles/data.d.ts

@@ -0,0 +1 @@
+export declare const PROFILE_DATA: Record<string, unknown>[];

package/dist/profiles/data.js

@@ -0,0 +1,411 @@
+// Generated by scripts/build-profiles.mjs from spec/profiles. Do not edit.
+export const PROFILE_DATA = [
+    {
+        "id": "amazon-polly",
+        "provider": "polly",
+        "models": [
+            "neural",
+            "generative",
+            "long-form",
+            "standard"
+        ],
+        "default": true,
+        "syntax": "ssml",
+        "escape": "xml",
+        "audio_tags": false,
+        "limit": {
+            "unit": "chars",
+            "max": 3000
+        },
+        "intents": {
+            "pause": {
+                "render": "<break time=\"{ms}ms\"/>",
+                "min_ms": 0,
+                "max_ms": 10000
+            },
+            "spell": {
+                "render": "spaced"
+            },
+            "emphasis": {
+                "render": "{text}"
+            },
+            "phoneme": {
+                "render": "<phoneme alphabet=\"ipa\" ph=\"{ipa}\">{text}</phoneme>"
+            }
+        },
+        "lexicon": {
+            "format": "pls",
+            "alphabet": "ipa"
+        },
+        "notes": "Output is the SSML body for `TextType=ssml`; the caller wraps it in <speak>. SynthesizeSpeech takes at most 3,000 billed characters (6,000 including tags); the profile counts everything, so 3,000 is safe. <break> caps at 10 seconds. <emphasis> is unavailable on neural, long-form and generative voices, so emphasis is rendered as plain text. <say-as interpret-as=\"characters\"> silently switches a neural voice to its standard counterpart for that sentence, so spelling is rendered as spaced characters instead. <phoneme> with IPA is supported (partially on generative). Lexicons are uploaded as PLS with PutLexicon.\n",
+        "sources": [
+            "https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html",
+            "https://docs.aws.amazon.com/polly/latest/dg/supportedtags.html",
+            "https://docs.aws.amazon.com/polly/latest/dg/break-tag.html",
+            "https://docs.aws.amazon.com/polly/latest/dg/say-as-tag.html"
+        ],
+        "verified": "2026-10-29"
+    },
+    {
+        "id": "azure-neural",
+        "provider": "azure",
+        "models": [
+            "neural",
+            "hd"
+        ],
+        "default": true,
+        "syntax": "ssml",
+        "escape": "xml",
+        "audio_tags": false,
+        "limit": {
+            "unit": "chars",
+            "max": 8000
+        },
+        "intents": {
+            "pause": {
+                "render": "<break time=\"{ms}ms\" />",
+                "min_ms": 0,
+                "max_ms": 20000
+            },
+            "spell": {
+                "render": "<say-as interpret-as=\"characters\">{text}</say-as>"
+            },
+            "emphasis": {
+                "render": "<emphasis level=\"strong\">{text}</emphasis>"
+            },
+            "phoneme": {
+                "render": "<phoneme alphabet=\"ipa\" ph=\"{ipa}\">{text}</phoneme>"
+            }
+        },
+        "lexicon": {
+            "format": "pls",
+            "alphabet": "ipa"
+        },
+        "notes": "Output is the SSML body: text with break, say-as and emphasis elements, with & < > escaped. The caller wraps it in <speak> and <voice>, since the voice name is theirs to choose. Azure caps audio at 10 minutes per request and the WebSocket SSML message at 64 KB; 8,000 characters stays well inside both at normal speaking rates. HD voices support a subset of SSML; check the HD page.\n",
+        "sources": [
+            "https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-synthesis-markup-structure",
+            "https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-services-quotas-and-limits"
+        ],
+        "verified": "2026-10-28"
+    },
+    {
+        "id": "cartesia-sonic",
+        "provider": "cartesia",
+        "models": [
+            "sonic-3.6",
+            "sonic-3.5",
+            "sonic-3",
+            "sonic-latest",
+            "sonic-2",
+            "sonic-turbo"
+        ],
+        "default": true,
+        "syntax": "plain",
+        "escape": "none",
+        "audio_tags": false,
+        "limit": {
+            "unit": "chars",
+            "max": null
+        },
+        "intents": {
+            "pause": {
+                "render": "<break time=\"{ms}ms\"/>",
+                "min_ms": 0
+            },
+            "spell": {
+                "render": "<spell>{text}</spell>"
+            },
+            "emphasis": {
+                "render": "{text}"
+            }
+        },
+        "lexicon": {
+            "format": "none"
+        },
+        "notes": "Sonic takes plain text with a small set of SSML-like tags, not SSML: <break time=\"500ms\"/>, <spell>ABC123</spell>, and speed, volume and emotion tags on sonic-3 and newer. Each tag counts as one character. Cartesia publishes no per-request transcript limit; its own guidance for agents is one sentence per request, which the streaming segmenter gives you. Cartesia runs its own text normalizer (request field `normalization`, default `auto`); its docs recommend pre-normalizing and setting `normalization: off` when you need full control of the spoken form, which is exactly what this library's output is for. Pronunciations are managed server-side through `pronunciation_dict_id`, so there is no lexicon export.\n",
+        "sources": [
+            "https://docs.cartesia.ai/api-reference/tts/bytes",
+            "https://docs.cartesia.ai/build-with-cartesia/capability-guides/ssml-tags",
+            "https://docs.cartesia.ai/build-with-cartesia/capability-guides/text-normalization",
+            "https://docs.cartesia.ai/build-with-cartesia/tts-models/latest"
+        ],
+        "verified": "2026-10-29"
+    },
+    {
+        "id": "deepgram-aura",
+        "provider": "deepgram",
+        "models": [
+            "aura-2",
+            "aura"
+        ],
+        "default": true,
+        "syntax": "plain",
+        "escape": "none",
+        "audio_tags": false,
+        "limit": {
+            "unit": "chars",
+            "max": 2000
+        },
+        "intents": {
+            "pause": {
+                "render": "punctuation"
+            },
+            "spell": {
+                "render": "spaced"
+            },
+            "emphasis": {
+                "render": "{text}"
+            }
+        },
+        "lexicon": {
+            "format": "none"
+        },
+        "notes": "Plain text only: no SSML, no pause or pronunciation markup, prosody only through the `speed` query parameter. Aura-2 covers English, Spanish, German, French, Dutch, Italian and Japanese; no Turkish. The 2,000 character cap is the figure Deepgram's REST reference carried at the Aura launch; the current pages state no number and their chunking guide works in 100 to 200 character sentence pieces, so treat 2,000 as the ceiling and stream sentences in practice.\n",
+        "sources": [
+            "https://developers.deepgram.com/reference/text-to-speech/speak-request",
+            "https://developers.deepgram.com/docs/tts-models",
+            "https://developers.deepgram.com/docs/text-chunking-for-tts-optimization"
+        ],
+        "verified": "2026-10-29"
+    },
+    {
+        "id": "elevenlabs-v2",
+        "provider": "elevenlabs",
+        "models": [
+            "eleven_multilingual_v2",
+            "eleven_flash_v2_5",
+            "eleven_flash_v2",
+            "eleven_turbo_v2_5",
+            "eleven_turbo_v2",
+            "eleven_multilingual_v1",
+            "eleven_monolingual_v1"
+        ],
+        "default": true,
+        "syntax": "plain",
+        "escape": "none",
+        "audio_tags": false,
+        "limit": {
+            "unit": "chars",
+            "max": 10000,
+            "per_model": {
+                "eleven_flash_v2_5": 40000,
+                "eleven_flash_v2": 30000
+            }
+        },
+        "intents": {
+            "pause": {
+                "render": "<break time=\"{s}s\" />",
+                "min_ms": 100,
+                "max_ms": 3000
+            },
+            "spell": {
+                "render": "spaced"
+            },
+            "emphasis": {
+                "render": "{text}"
+            }
+        },
+        "lexicon": {
+            "format": "pls",
+            "alphabet": "ipa"
+        },
+        "notes": "Models before v3 accept the SSML break tag and nothing else from SSML. Pauses are capped at 3 seconds; the docs warn that many breaks in one request can destabilise output, so keep them few. Dashes and ellipses are the documented fallback. Character limits per model come from the models overview page; turbo models list none there, so they inherit the 10,000 default.\n",
+        "sources": [
+            "https://elevenlabs.io/docs/product/prompting/pauses",
+            "https://elevenlabs.io/docs/overview/models"
+        ],
+        "verified": "2026-10-27"
+    },
+    {
+        "id": "elevenlabs-v3",
+        "provider": "elevenlabs",
+        "models": [
+            "eleven_v3",
+            "eleven_v3_conversational",
+            "eleven_v4",
+            "eleven_v4_turbo"
+        ],
+        "default": false,
+        "syntax": "plain",
+        "escape": "none",
+        "audio_tags": true,
+        "limit": {
+            "unit": "chars",
+            "max": 5000,
+            "per_model": {
+                "eleven_v4": 10000
+            }
+        },
+        "intents": {
+            "pause": {
+                "render": "punctuation"
+            },
+            "spell": {
+                "render": "spaced"
+            },
+            "emphasis": {
+                "render": "{text}"
+            }
+        },
+        "lexicon": {
+            "format": "pls",
+            "alphabet": "ipa"
+        },
+        "notes": "v3 and v4 do not accept SSML break tags. Pacing comes from punctuation and audio tags such as [short pause]; unknown bracket tags made of words pass through for these models. Limits: eleven_v3 5,000 characters, eleven_v4 10,000; the conversational and turbo variants list none, so they take the 5,000 default until verified.\n",
+        "sources": [
+            "https://elevenlabs.io/docs/product/prompting/pauses",
+            "https://elevenlabs.io/docs/overview/models"
+        ],
+        "verified": "2026-10-27"
+    },
+    {
+        "id": "google-chirp3",
+        "provider": "google",
+        "models": [
+            "chirp3-hd",
+            "chirp-hd",
+            "gemini-tts"
+        ],
+        "default": true,
+        "syntax": "plain",
+        "escape": "none",
+        "audio_tags": false,
+        "limit": {
+            "unit": "bytes",
+            "max": 5000
+        },
+        "intents": {
+            "pause": {
+                "render": "punctuation"
+            },
+            "spell": {
+                "render": "spaced"
+            },
+            "emphasis": {
+                "render": "{text}"
+            }
+        },
+        "lexicon": {
+            "format": "google",
+            "alphabet": "ipa"
+        },
+        "notes": "Chirp 3 HD takes plain text in `input.text`; SSML on these voices is a preview that works only for synchronous requests, so this profile stays plain. Pauses can be steered with `[pause]`, `[pause short]` and `[pause long]`, but only in the `input.markup` field, never in `text`, so the profile renders pauses as punctuation and leaves markup to callers who use that field. Pronunciations go in the request's `custom_pronunciations` list (IPA or X-SAMPA), which is what the google lexicon export produces. The request body is capped at 5,000 bytes.\n",
+        "sources": [
+            "https://docs.cloud.google.com/text-to-speech/docs/chirp3-hd",
+            "https://docs.cloud.google.com/text-to-speech/quotas"
+        ],
+        "verified": "2026-10-29"
+    },
+    {
+        "id": "google-ssml",
+        "provider": "google",
+        "models": [
+            "neural2",
+            "wavenet",
+            "studio",
+            "standard",
+            "polyglot"
+        ],
+        "default": false,
+        "syntax": "ssml",
+        "escape": "xml",
+        "audio_tags": false,
+        "limit": {
+            "unit": "bytes",
+            "max": 5000
+        },
+        "intents": {
+            "pause": {
+                "render": "<break time=\"{ms}ms\"/>",
+                "min_ms": 0
+            },
+            "spell": {
+                "render": "<say-as interpret-as=\"characters\">{text}</say-as>"
+            },
+            "emphasis": {
+                "render": "<emphasis level=\"moderate\">{text}</emphasis>"
+            },
+            "phoneme": {
+                "render": "<phoneme alphabet=\"ipa\" ph=\"{ipa}\">{text}</phoneme>"
+            }
+        },
+        "lexicon": {
+            "format": "none"
+        },
+        "notes": "The classic voice families take full SSML in `input.ssml`. Output is the body; the caller wraps it in <speak>. Studio voices ignore <emphasis>, <mark>, <prosody pitch> and <lang>. Google documents no upper bound for <break time>. The 5,000-byte cap counts the SSML tags too. There is no lexicon upload for these voices, so lexicon entries are rendered inline as <phoneme> tags.\n",
+        "sources": [
+            "https://docs.cloud.google.com/text-to-speech/docs/ssml",
+            "https://docs.cloud.google.com/text-to-speech/docs/list-voices-and-types",
+            "https://docs.cloud.google.com/text-to-speech/quotas"
+        ],
+        "verified": "2026-10-29"
+    },
+    {
+        "id": "openai-tts",
+        "provider": "openai",
+        "models": [
+            "gpt-4o-mini-tts",
+            "gpt-4o-mini-tts-2025-12-15",
+            "tts-1",
+            "tts-1-hd"
+        ],
+        "default": true,
+        "syntax": "plain",
+        "escape": "none",
+        "audio_tags": false,
+        "limit": {
+            "unit": "chars",
+            "max": 4096
+        },
+        "intents": {
+            "pause": {
+                "render": "punctuation"
+            },
+            "spell": {
+                "render": "spaced"
+            },
+            "emphasis": {
+                "render": "{text}"
+            }
+        },
+        "lexicon": {
+            "format": "none"
+        },
+        "notes": "No SSML. Tone is steered with the separate `instructions` request parameter, which does not work with tts-1 or tts-1-hd. The input is capped at 4,096 characters. OpenAI has announced that these models shut down on 6 January 2027 in favour of the Realtime API, so this profile is maintained until then.\n",
+        "sources": [
+            "https://developers.openai.com/api/docs/api-reference/audio/createSpeech",
+            "https://developers.openai.com/api/docs/guides/text-to-speech"
+        ],
+        "verified": "2026-10-28"
+    },
+    {
+        "id": "plain",
+        "provider": "plain",
+        "models": [],
+        "default": true,
+        "syntax": "plain",
+        "escape": "none",
+        "audio_tags": false,
+        "limit": {
+            "unit": "chars",
+            "max": null
+        },
+        "intents": {
+            "pause": {
+                "render": "punctuation"
+            },
+            "spell": {
+                "render": "spaced"
+            },
+            "emphasis": {
+                "render": "{text}"
+            }
+        },
+        "lexicon": {
+            "format": "none"
+        },
+        "notes": "Provider-neutral output. Pauses become punctuation, spell-outs become spaced characters, emphasis is dropped. No request limit, so one chunk.\n",
+        "sources": [],
+        "verified": "2026-10-27"
+    }
+];

package/dist/profiles/index.d.ts

@@ -0,0 +1,35 @@
+/** Provider profiles: data files that say what each TTS model accepts.
+ *
+ * The YAML files live in the repository's `spec/profiles`. The build step turns
+ * them into `data.ts` so the package needs no YAML parser at runtime. Each
+ * profile states the intent renderings, the request limit, the escaping rules
+ * and whether unknown bracket tags pass through.
+ */
+export interface Profile {
+    id: string;
+    provider: string;
+    models: string[];
+    /** plain | ssml */
+    syntax: string;
+    /** none | xml */
+    escape: string;
+    /** chars | bytes */
+    limitUnit: string;
+    limitMax: number | null;
+    limitPerModel: Record<string, number>;
+    intents: Record<string, Record<string, unknown>>;
+    audioTags: boolean;
+    /** pls | google | none: how a lexicon is uploaded to this provider */
+    lexiconFormat: string;
+    lexiconAlphabet: string;
+    default: boolean;
+    notes: string;
+    sources: string[];
+    verified: string;
+    raw: Record<string, unknown>;
+    limitFor(model?: string | null): number | null;
+}
+export declare function listProfiles(): Profile[];
+export declare function loadProfile(profileId: string): Profile;
+/** Pick the profile for a provider and model. No provider = the `plain` profile. */
+export declare function resolveProfile(provider?: string | null, model?: string | null): Profile;