@gentbajko/slopify 1.5.0 → 2.0.0

package/dist/slices/narration/pronunciation.js

@@ -0,0 +1,126 @@
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+// Inworld requires English IPA, not every symbol in Unicode's IPA Extensions block.
+// https://docs.inworld.ai/tts/capabilities/custom-pronunciation
+const ipaAtom = "[ˈˌ]?[abdefghijklmnoprstuvwxzæðŋθɑɒɔəɚɛɜɝɡɪɹʃʊʌʒʔɫɾ][\\u0303\\u031a\\u0325\\u0329\\u032a\\u032c\\u032f\\u035c\\u0361ʰʲʷ]*[ːˑ]?";
+const ipaSymbols = new RegExp(`^(?:${ipaAtom})+(?:\\.(?:${ipaAtom})+)*$`, "u");
+function textOf(node) {
+    if (node.type === "break")
+        return "\n";
+    return node.value ?? node.children?.map(textOf).join("") ?? "";
+}
+function rowsOf(node) {
+    if (node.type === "heading") {
+        const text = textOf(node).trim();
+        return /^pronunciation glossary:?\s*$/iu.test(text) ? [] : [text];
+    }
+    if (node.type === "table") {
+        const rows = node.children ?? [];
+        return rows.slice(1).map((row) => {
+            const cells = row.children ?? [];
+            return cells.length >= 2 ? cells.slice(0, 2).map(textOf).join(": ") : textOf(row);
+        });
+    }
+    if (node.type === "paragraph")
+        return textOf(node).split(/\r?\n/u);
+    if (node.type === "root" || node.type === "list" || node.type === "listItem")
+        return (node.children ?? []).flatMap(rowsOf);
+    return ["(unsupported glossary block)"];
+}
+function refused(row, reason) {
+    return {
+        ok: false,
+        reason: "Pronunciation Glossary entry " +
+            row +
+            ": " +
+            reason +
+            ". Edit the glossary or turn off Use Pronunciation Glossary.",
+    };
+}
+function termIdentity(term) {
+    return Array.from(term, (character) => {
+        const lower = character.toLowerCase();
+        const folded = lower.toUpperCase().toLowerCase();
+        if (folded === character)
+            return character;
+        // Full case conversion can expand letters; only /iu-equivalent forms may share a key.
+        const match = new RegExp(`^${character.replace(/[|\\{}()[\]^$+*?.]/gu, "\\$&")}$`, "iu");
+        return match.test(folded) ? folded : match.test(lower) ? lower : character;
+    }).join("");
+}
+export function parsePronunciationGlossary(markdown) {
+    const rows = rowsOf(remark().use(remarkGfm).parse(markdown));
+    const entries = new Map();
+    for (const [index, row] of rows.entries()) {
+        const trimmed = row.trim();
+        if (trimmed === "" || /^pronunciation glossary:?\s*$/iu.test(trimmed))
+            continue;
+        const pair = /^([^:]+):\s*(.+)$/u.exec(trimmed);
+        const term = pair?.[1]?.trim().replace(/\s+/gu, " ");
+        const pronunciation = pair?.[2];
+        if (term === undefined ||
+            pronunciation === undefined ||
+            !/[\p{L}\p{N}]/u.test(term) ||
+            /[/[\]<>\p{Cc}]/u.test(term))
+            return refused(index + 1, "use Term: /IPA/ or a Term | IPA table");
+        const notation = /^(\/[^/]+\/(?:\s+\/[^/]+\/)*)(?:\s+[^/]+)?$/u.exec(pronunciation);
+        if (notation?.[1] === undefined)
+            return refused(index + 1, "use slash-delimited standard-English IPA");
+        const ipa = Array.from(notation[1].matchAll(/\/([^/]+)\//gu)).flatMap((match) => (match[1] ?? "").trim().split(/\s+/u));
+        if (ipa.length === 0 || ipa.some((word) => !ipaSymbols.test(word)))
+            return refused(index + 1, "use standard-English IPA, not ARPAbet or delivery tags");
+        if (term.split(" ").length !== ipa.length)
+            return refused(index + 1, "supply one IPA word for each written word");
+        const key = termIdentity(term);
+        const previous = entries.get(key);
+        if (previous !== undefined && previous.ipa.join(" ") !== ipa.join(" "))
+            return refused(index + 1, "conflicting pronunciations were supplied for the same term");
+        if (previous === undefined)
+            entries.set(key, { term, ipa });
+    }
+    return { ok: true, entries: [...entries.values()] };
+}
+export function pronunciationMatches(source, entries) {
+    if (entries.length === 0)
+        return [];
+    const ordered = [...entries].sort((a, b) => b.term.length - a.term.length);
+    const patterns = ordered.map((entry) => entry.term
+        .split(" ")
+        .map((word) => word.replace(/[|\\{}()[\]^$+*?.]/gu, "\\$&"))
+        .join("\\s+"));
+    const boundary = "[\\p{L}\\p{M}\\p{N}_\\-\u00ad\u2010\u2011\ufe63\uff0d]";
+    const expression = new RegExp("(?<!" +
+        boundary +
+        "['’]?)(?:" +
+        patterns.map((pattern) => `(${pattern})`).join("|") +
+        ")(?!['’]?" +
+        boundary +
+        ")", "giu");
+    const matches = [];
+    for (const match of source.matchAll(expression)) {
+        const end = match.index + match[0].length;
+        const before = source[match.index - 1];
+        const after = source[end];
+        if ((after === "'" && before !== "'") || (after === "’" && before !== "‘"))
+            continue;
+        const entry = ordered.find((_, index) => match[index + 1] !== undefined);
+        if (entry === undefined)
+            throw new Error("Matched glossary term has no mapping.");
+        matches.push({ start: match.index, end, entry });
+    }
+    return matches;
+}
+export function pronunciationSpans(source, entries) {
+    const spans = [];
+    for (const match of pronunciationMatches(source, entries)) {
+        const words = source.slice(match.start, match.end).matchAll(/\S+/gu);
+        for (const [index, word] of Array.from(words).entries()) {
+            const ipa = match.entry.ipa[index];
+            if (ipa === undefined)
+                throw new Error("Validated glossary term has no IPA word.");
+            const start = match.start + word.index;
+            spans.push({ start, end: start + word[0].length, text: `/${ipa}/` });
+        }
+    }
+    return spans;
+}

package/dist/slices/narration/steering.js

@@ -1,9 +1,68 @@
 import { sourceSentences } from "./preparation.js";
 const cannotFit = {
     ok: false,
-    reason: "Delivery cues or whitespace leave no room for narration at this model's character limit.",
+    reason: "Delivery cues, an indivisible IPA token or whitespace leave no room for narration at this model's character limit.",
 };
-export function prepareRequests(source, cues, maxCharacters) {
+function atoms(source, from, to, spans) {
+    const result = [];
+    for (let at = from; at < to;) {
+        const span = spans.get(at);
+        if (span !== undefined) {
+            if (span.end > to || span.end <= at)
+                throw new Error("Pronunciation span crosses a word.");
+            result.push({ text: span.text, spokenText: source.slice(at, span.end) });
+            at = span.end;
+        }
+        else {
+            const point = source.codePointAt(at);
+            if (point === undefined)
+                throw new Error("Narration offset is outside the source.");
+            const text = String.fromCodePoint(point);
+            result.push({ text, spokenText: text });
+            at += text.length;
+        }
+    }
+    return result;
+}
+function checkedSpans(source, pronunciation) {
+    const spans = new Map();
+    let end = 0;
+    for (const span of [...pronunciation].sort((a, b) => a.start - b.start)) {
+        if (!Number.isInteger(span.start) ||
+            !Number.isInteger(span.end) ||
+            span.start < end ||
+            span.end <= span.start ||
+            span.end > source.length ||
+            !/^[^\s\uD800-\uDFFF]+$/u.test(source.slice(span.start, span.end)))
+            throw new Error("Pronunciation spans must cover disjoint whole source characters in a word.");
+        spans.set(span.start, span);
+        end = span.end;
+    }
+    return spans;
+}
+function anchoredParts(source, cues, spans) {
+    const bySentence = new Map();
+    for (const cue of cues) {
+        const group = bySentence.get(cue.sentence) ?? [];
+        group.push(cue);
+        bySentence.set(cue.sentence, group);
+    }
+    const anchors = new Map();
+    let offset = 0;
+    for (const sentence of sourceSentences(source)) {
+        const start = spans.find((span) => span.start < offset && offset < span.end)?.start ?? offset;
+        const events = anchors.get(start) ?? [];
+        events.push(...(bySentence.get(sentence.sentence) ?? []));
+        anchors.set(start, events);
+        offset += sentence.text.length;
+    }
+    return [...anchors].map(([start, events], index, boundaries) => ({
+        start,
+        text: source.slice(start, boundaries[index + 1]?.[0] ?? source.length),
+        events,
+    }));
+}
+export function prepareRequests(source, cues, maxCharacters, pronunciation = []) {
     if (!Number.isInteger(maxCharacters) || maxCharacters < 2)
         return {
             ok: false,
@@ -11,13 +70,8 @@ export function prepareRequests(source, cues, maxCharacters) {
         };
     if (source.trim() === "")
         return { ok: true, requests: [] };
+    const spans = checkedSpans(source, pronunciation);
     const requests = [];
-    const bySentence = new Map();
-    for (const cue of cues) {
-        const group = bySentence.get(cue.sentence) ?? [];
-        group.push(cue);
-        bySentence.set(cue.sentence, group);
-    }
     let active = null;
     let text = "";
     let spokenText = "";
@@ -29,17 +83,19 @@ export function prepareRequests(source, cues, maxCharacters) {
         spokenText = "";
         return true;
     };
-    for (const sentence of sourceSentences(source)) {
-        const events = bySentence.get(sentence.sentence) ?? [];
-        const direction = events.find((cue) => cue.kind !== "sound");
+    for (const part of anchoredParts(source, cues, pronunciation)) {
+        const events = part.events;
+        const direction = pronunciation.length === 0
+            ? events.find((cue) => cue.kind !== "sound")
+            : events.findLast((cue) => cue.kind !== "sound");
         const tags = events.map(cueTag).join(" ");
         const prefix = tags === "" ? "" : `${tags} `;
-        const first = Array.from(sentence.text)[0] ?? "";
-        const words = sentence.text.match(/\S+\s*|\s+/gu) ?? [];
-        const firstWord = words[0] ?? first;
+        const words = Array.from(part.text.matchAll(/\S+\s*|\s+/gu)).map((match) => atoms(source, part.start + match.index, part.start + match.index + match[0].length, spans));
+        const first = words[0]?.[0]?.text ?? "";
+        const firstWordLength = words[0]?.reduce((length, atom) => length + atom.text.length, 0) ?? 0;
         const freshPrefix = direction === undefined ? carryTag(active) : "";
-        const minimum = firstWord.length + prefix.length + freshPrefix.length <= maxCharacters
-            ? firstWord.length
+        const minimum = firstWordLength + prefix.length + freshPrefix.length <= maxCharacters
+            ? firstWordLength
             : first.length;
         if (spokenText.trim() !== "" && text.length + prefix.length + minimum > maxCharacters) {
             if (!flush())
@@ -52,24 +108,26 @@ export function prepareRequests(source, cues, maxCharacters) {
         text += prefix;
         if (direction !== undefined)
             active = direction.kind === "instruction" ? direction.text : null;
-        for (const word of words) {
-            if (word.length + carryTag(active).length <= maxCharacters &&
-                text.length + word.length > maxCharacters &&
+        for (const [index, word] of words.entries()) {
+            const length = word.reduce((sum, atom) => sum + atom.text.length, 0);
+            if ((index > 0 || prefix === "" || spans.size === 0) &&
+                length + carryTag(active).length <= maxCharacters &&
+                text.length + length > maxCharacters &&
                 spokenText.trim() !== "") {
                 if (!flush())
                     return cannotFit;
                 text = carryTag(active);
             }
-            for (const point of word) {
-                if (text.length + point.length > maxCharacters) {
+            for (const atom of word) {
+                if (text.length + atom.text.length > maxCharacters) {
                     if (!flush())
                         return cannotFit;
                     text = carryTag(active);
                 }
-                if (text.length + point.length > maxCharacters)
+                if (text.length + atom.text.length > maxCharacters)
                     return cannotFit;
-                text += point;
-                spokenText += point;
+                text += atom.text;
+                spokenText += atom.spokenText;
             }
         }
     }

package/dist/slices/play-drafts/convert.js

@@ -59,7 +59,9 @@ export function toAdmissionDraft(input) {
         format: form.format,
         sources,
         llm: form.llm,
-        audio: sources.audio === "generate" ? form.audio : undefined,
+        audio: sources.audio === "generate" || form.audio.usePronunciationGlossary !== undefined
+            ? form.audio
+            : undefined,
         images: form.images,
         articlePrompt: sources.article === "generate" ? form.articlePrompt : undefined,
         ...(sources.audio === "generate" && form.narrationPrompt?.trim()

package/dist/slices/play-drafts/schema.js

@@ -31,7 +31,9 @@ export const playDraftFormSchema = z
         .strict()
         .readonly(),
     llm: provider.readonly(),
-    audio: provider.extend({ voice: text }).readonly(),
+    audio: provider
+        .extend({ voice: text, usePronunciationGlossary: z.boolean().optional() })
+        .readonly(),
     images: provider.readonly(),
     articlePrompt: text,
     narrationPrompt: text.optional(),

package/dist/slices/rebuild/admission-repo.js

@@ -8,6 +8,7 @@ import { executionSnapshotSchema, planPreview, reviewStillCovers } from "./previ
 import { previewById } from "./repo.js";
 import { insertInvocation, reservationKey } from "./runtime-admission.js";
 import { bindNarrationReuse } from "./runtime-narration-reuse.js";
+import { executionCatalogue } from "./runtime-plan.js";
 import { projectStandings } from "./runtime-store.js";
 export function admissionReceipt(db, projectId, idempotencyKey, requestHash) {
     const row = db
@@ -24,8 +25,9 @@ export function admissionReceipt(db, projectId, idempotencyKey, requestHash) {
                 },
             };
     if (db
-        .prepare("SELECT 1 FROM revision_mutations WHERE project_id=? AND idempotency_key=? UNION ALL SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
-        .get(projectId, idempotencyKey, projectId, idempotencyKey) !== undefined)
+        .prepare("SELECT 1 FROM revision_mutations WHERE project_id=? AND idempotency_key=? UNION ALL SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=? UNION ALL SELECT 1 FROM project_recovery_requests WHERE project_id=? AND idempotency_key=?")
+        .get(projectId, idempotencyKey, projectId, idempotencyKey, projectId, idempotencyKey) !==
+        undefined)
         return { ok: false, reason: "conflict" };
     return undefined;
 }
@@ -49,9 +51,10 @@ export function admitPreview(deps, input) {
         const view = getRevisionView(deps, preview.projectId, preview.baseRevisionId);
         if (view === undefined)
             return { ok: false, reason: "no-project" };
-        const fresh = planPreview(deps, view, snapshot.catalogue, preview.selection, preview.id);
+        const fresh = planPreview(deps, view, input.planningCatalogue, preview.selection, preview.id);
         if (!fresh.ok || !reviewStillCovers(preview, snapshot, fresh.value))
             return { ok: false, reason: "stale-preview" };
+        const catalogue = executionCatalogue(input.planningCatalogue, view.revision.config);
         const admissionId = deps.ids.next();
         const workIds = [];
         for (const recipe of snapshot.recipes) {
@@ -97,7 +100,7 @@ export function admitPreview(deps, input) {
             const fingerprint = snapshot.anchors[key];
             if (fingerprint === undefined)
                 throw new Error("Selected work has no reviewed desired anchor.");
-            const work = insertInvocation(deps, view, recipe, snapshot.catalogue, { key, fingerprint }, false, view.revision.id, admissionId);
+            const work = insertInvocation(deps, view, recipe, catalogue, { key, fingerprint }, false, view.revision.id, admissionId);
             workIds.push(work.workId);
         }
         const receipt = {

package/dist/slices/rebuild/preview-plan.js

@@ -129,7 +129,7 @@ export function planPreview(deps, view, catalogue, selection, id) {
         return {
             key: row.key,
             submit,
-            uncertain: submit && hasSubmittedRequest(deps, view.revision.id, row.key, row.fingerprint),
+            uncertain: submit && hasSubmittedRequest(deps, view.revision.id, row.key),
         };
     });
     const execution = {

package/dist/slices/rebuild/preview-retained.js

@@ -28,6 +28,19 @@ export function retainedPreviewPlan(deps, view, catalogue) {
         const recipe = original.recipes.find((one) => one.key === piece.key);
         if (recipe === undefined)
             continue;
+        // Pre-1.5 requests embedded research in messages. Review a fresh document-based
+        // request instead of re-admitting an input the current scheduler cannot match.
+        // Running calls, accepted jobs and cached answers must retain their exact input.
+        if ((piece.key === "research:notes" || piece.key === "article:body") &&
+            piece.input.kind === "llm" &&
+            (piece.input.documents?.length ?? 0) === 0 &&
+            recipe.input.kind === "llm" &&
+            (recipe.input.documents?.length ?? 0) > 0 &&
+            row.state !== "running" &&
+            !deps.db
+                .prepare("SELECT 1 FROM revision_work_pieces WHERE work_id=? AND (state IN ('running','done') OR continuation IS NOT NULL OR result_json IS NOT NULL) LIMIT 1")
+                .get(piece.workId))
+            continue;
         replacements.set(piece.key, {
             ...recipe,
             input: piece.input,
@@ -121,8 +134,8 @@ function cachedArticleComplete(deps, revisionId, workId) {
     }
     return false;
 }
-export function hasSubmittedRequest(deps, revisionId, key, fingerprint) {
+export function hasSubmittedRequest(deps, revisionId, key) {
     return (deps.db
-        .prepare(`SELECT 1 FROM revision_work_reservations r JOIN revision_work_pieces p ON p.id=r.piece_id WHERE r.revision_id=? AND r.work_key=? AND r.fingerprint=? AND p.submitted_at IS NOT NULL AND p.continuation IS NULL AND p.state!='done'`)
-        .get(revisionId, key, fingerprint) !== undefined);
+        .prepare(`SELECT 1 FROM revision_work_reservations r JOIN revision_work_pieces p ON p.id=r.piece_id WHERE r.revision_id=? AND r.work_key=? AND p.submitted_at IS NOT NULL AND p.continuation IS NULL AND p.state!='done'`)
+        .get(revisionId, key) !== undefined);
 }

package/dist/slices/rebuild/recipe-audio-parts.js

@@ -1,8 +1,10 @@
-import { usesNarrationPreparation } from "../admission/rules.js";
+import { usesNarrationPreparation, usesPronunciationGlossary } from "../admission/rules.js";
 import { narrationRegenerationToken, normalizeNarrationText, planNarration, } from "../narration/plan.js";
+import { pronunciationSpans } from "../narration/pronunciation.js";
+import { prepareRequests } from "../narration/steering.js";
 import { recipe } from "./recipe-model.js";
 import { preparationForGroup } from "./recipe-preparation.js";
-export function narrationParts(context, logicalKey, originalText, segment, dependsOn, preparations) {
+export function narrationParts(context, logicalKey, originalText, segment, dependsOn, preparations, glossary) {
     const override = context.content.narrationOverrides[logicalKey];
     if (override?.kind === "asset")
         return [
@@ -13,25 +15,26 @@ export function narrationParts(context, logicalKey, originalText, segment, depen
                 semantic: [normalizeNarrationText(originalText), voiceValues(context)],
             }, dependsOn, { tokenKey: logicalKey }),
         ];
+    if (glossary === null)
+        return [];
+    if (!glossary.ok)
+        return [refusedPart(context, logicalKey, dependsOn, glossary.reason)];
     const logicalText = normalizeNarrationText(override?.kind === "text" ? override.text : originalText);
+    const spans = pronunciationSpans(logicalText, glossary.entries);
     const wholeRequest = segment !== "body" || (context.config.chunking?.mode ?? "whole") === "whole";
     const choice = context.config.audio;
     const model = context.catalogue?.tts.find((row) => row.provider === choice?.provider &&
         row.id === choice.model &&
         row.enabled &&
         !row.deprecated);
+    const logicalLimit = Math.max(2, logicalText.length +
+        spans.reduce((sum, span) => sum + Math.max(0, span.text.length - (span.end - span.start)), 0));
+    const maxCharacters = model?.tts.maxCharacters ?? logicalLimit;
     if (usesNarrationPreparation(context.config)) {
-        const prepared = preparationForGroup(context, logicalKey, logicalText, segment, dependsOn, model?.tts.maxCharacters ?? Math.max(2, logicalText.length));
+        const prepared = preparationForGroup(context, logicalKey, logicalText, segment, dependsOn, maxCharacters, spans);
         preparations.push(prepared.preparation);
         if (prepared.refusal !== null)
-            return [
-                recipe(context, `${logicalKey}:1`, "audio", {
-                    kind: "deferred",
-                    version: 1,
-                    operation: "resolve-revision-recipe",
-                    template: prepared.refusal,
-                }, [prepared.preparation.key], { unresolved: true, refusal: prepared.refusal }),
-            ];
+            return [refusedPart(context, logicalKey, [prepared.preparation.key], prepared.refusal)];
         return (prepared.requests ?? []).map(({ text, spokenText }, index) => recipe(context, `${logicalKey}:${index + 1}`, "audio", {
             kind: "tts",
             version: 1,
@@ -47,6 +50,26 @@ export function narrationParts(context, logicalKey, originalText, segment, depen
             wholeRequest,
         }, [prepared.preparation.key], { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
     }
+    if (spans.length > 0) {
+        const prepared = prepareRequests(logicalText, [], maxCharacters, spans);
+        if (!prepared.ok)
+            return [refusedPart(context, logicalKey, dependsOn, prepared.reason)];
+        return prepared.requests.map(({ text, spokenText }, index) => recipe(context, `${logicalKey}:${index + 1}`, "audio", {
+            kind: "tts",
+            version: 1,
+            provider: choice?.provider ?? "",
+            model: choice?.model ?? "",
+            voice: choice?.voice ?? "",
+            text,
+            spokenText,
+            logicalKey,
+            logicalText,
+            segment,
+            pronunciation: null,
+            wholeRequest,
+        }, dependsOn, { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
+    }
+    // Preserve the pre-feature splitter, shape and identities when no term matches.
     const requests = planNarration({
         groups: [
             {
@@ -60,9 +83,7 @@ export function narrationParts(context, logicalKey, originalText, segment, depen
         provider: choice?.provider ?? "",
         model: choice?.model ?? "",
         voice: choice?.voice ?? "",
-        maxCharacters: context.catalogue === undefined
-            ? Math.max(2, logicalText.length)
-            : (model?.tts.maxCharacters ?? Math.max(2, logicalText.length)),
+        maxCharacters,
         retained: [],
     });
     return requests.map(({ text, key }) => recipe(context, key, "audio", {
@@ -79,6 +100,41 @@ export function narrationParts(context, logicalKey, originalText, segment, depen
         wholeRequest,
     }, dependsOn, { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
 }
+function refusedPart(context, logicalKey, dependsOn, reason) {
+    return recipe(context, `${logicalKey}:1`, "audio", { kind: "deferred", version: 1, operation: "resolve-revision-recipe", template: reason }, dependsOn, { unresolved: true, refusal: reason });
+}
+export function pronunciationFutureValues(context, glossary, article, logicalKey, source) {
+    if (!usesPronunciationGlossary(context.config))
+        return [];
+    const override = context.content.narrationOverrides[logicalKey];
+    if (override?.kind === "asset")
+        return [];
+    if (glossary === null)
+        return [["pronunciation-glossary-v1", "pending-article", article.fingerprint]];
+    if (!glossary.ok)
+        return [["pronunciation-glossary-v1", "invalid", glossary.reason]];
+    // Unknown generated entry text may match any supplied term.
+    if (source === null)
+        return glossary.entries.length === 0
+            ? []
+            : [
+                [
+                    "pronunciation-glossary-v1",
+                    glossary.entries.map((entry) => [entry.term, [...entry.ipa]]),
+                ],
+            ];
+    const clean = normalizeNarrationText(override?.kind === "text" ? override.text : source);
+    const spans = pronunciationSpans(clean, glossary.entries);
+    return spans.length === 0
+        ? []
+        : [
+            [
+                "pronunciation-glossary-v1",
+                logicalKey,
+                spans.map((span) => [span.start, span.end, span.text]),
+            ],
+        ];
+}
 export function voiceValues(context) {
     return [
         context.config.audio?.provider ?? null,