@pie-players/tts-server-sc 0.3.67 → 0.3.68

package/README.md

@@ -160,6 +160,45 @@ const result = await provider.synthesize({
 });
 ```
 
+## Voice discovery
+
+The service serves 29 locales with one default voice each, and exposes no
+endpoint to ask which. `getVoices()` answers from a table transcribed from the
+map the service reads (`src/helpers/voices.js`), so it costs no request and
+works before any credential is configured:
+
+```ts
+await provider.getVoices();                      // all 29 locales
+await provider.getVoices({ language: "es" });    // es-ES, es-MX, es-US
+await provider.getVoices({ language: "en-GB" }); // en-GB and en-GB-WLS
+```
+
+`language` is a language range matched per RFC 4647 basic filtering, so a bare
+primary subtag reaches every locale under it. Every voice is a Polly *standard*
+voice — the service sends no `Engine` — so `quality: "neural"` answers with an
+empty list rather than a voice that cannot be produced.
+
+A `Voice.id` is the Polly `VoiceId`, which is what `synthesize` takes back as
+`voice`. The service accepts any voice Polly knows; the table names only the
+default per locale, which is what it substitutes when a request omits `voice`.
+
+The same data is available without a provider instance, which is what a route
+serving a picker wants:
+
+```ts
+import {
+  schoolCityVoices,
+  isSupportedSchoolCityLanguage,
+} from "@pie-players/tts-server-sc";
+
+schoolCityVoices({ gender: "male" });
+isSupportedSchoolCityLanguage("es-419"); // false
+```
+
+Check the locale before synthesizing. An unrecognized `lang_id` is not an error
+upstream — the service rewrites it to `en-US` and returns English audio, so an
+unserved locale fails silently rather than loudly.
+
 ## Dogfood adapter example (section-demos shape)
 
 If you need to return the SchoolCity-style response shape (`audioContent`, `word`) while reusing provider logic:

package/dist/SchoolCityServerProvider.d.ts

@@ -74,7 +74,15 @@ export declare class SchoolCityServerProvider extends BaseTTSProvider {
     private withTimeout;
     synthesizeWithAssets(request: SynthesizeRequest): Promise<SchoolCitySynthesizeAssetsResult>;
     synthesize(request: SynthesizeRequest): Promise<SynthesizeResponse>;
-    getVoices(_options?: GetVoicesOptions): Promise<Voice[]>;
+    /**
+     * The service's locale roster, from the table it reads itself.
+     *
+     * Not a network call: the service has no voice or locale endpoint to ask, so
+     * `sc-voices.ts` transcribes the map behind `POST /` instead. Returning `[]`,
+     * as this did, left the 29 locales reachable only by a caller that already
+     * knew a `lang_id` to hardcode.
+     */
+    getVoices(options?: GetVoicesOptions): Promise<Voice[]>;
     getCapabilities(): ServerProviderCapabilities;
 }
 export {};

package/dist/SchoolCityServerProvider.js

@@ -1,6 +1,7 @@
 import { SignJWT } from "jose";
 import { getDomain } from "tldts";
-import { BaseTTSProvider, TTSError, TTSErrorCode, } from "@pie-players/tts-server-core";
+import { BaseTTSProvider, normalizeSpeechMarks, resolveSpeedRateBucket, resolveTTSErrorCodeForHttpStatus, TTSError, TTSErrorCode, } from "@pie-players/tts-server-core";
+import { schoolCityVoices } from "./sc-voices.js";
 const DEFAULT_LANGUAGE = "en-US";
 const DEFAULT_SPEED_RATE = "medium";
 const DEFAULT_CACHE = true;
@@ -207,17 +208,6 @@ const fetchAssetWithManualRedirects = async (initialUrl, config, baseUrl, fetchI
     // Unreachable: loop either returns or throws.
     throw new TTSError(TTSErrorCode.PROVIDER_ERROR, "SchoolCity asset fetch terminated unexpectedly", undefined, "schoolcity-tts");
 };
-const asFiniteNumber = (value) => {
-    const next = Number(value);
-    return Number.isFinite(next) ? next : null;
-};
-const sortSpeechMarks = (marks) => [...marks].sort((left, right) => {
-    if (left.time !== right.time)
-        return left.time - right.time;
-    if (left.start !== right.start)
-        return left.start - right.start;
-    return left.end - right.end;
-});
 const parseResponseBody = async (response) => {
     const raw = await response.text();
     if (!raw)
@@ -236,12 +226,7 @@ const toSpeedRate = (request, fallback) => {
     if (explicit === "slow" || explicit === "medium" || explicit === "fast") {
         return explicit;
     }
-    const rate = Number(request.rate ?? 1);
-    if (!Number.isFinite(rate) || rate <= 0.95)
-        return "slow";
-    if (rate >= 1.5)
-        return "fast";
-    return fallback;
+    return resolveSpeedRateBucket(request.rate, fallback);
 };
 const toLanguage = (request, fallback) => {
     const providerOptions = (request.providerOptions || {});
@@ -275,114 +260,6 @@ const normalizeTextForSchoolCity = (input) => {
     const withoutOpen = text.replace(/^\s*<speak[^>]*>/i, "");
     return withoutOpen.replace(/<\/speak>\s*$/i, "").trim();
 };
-const parseWordMarksJsonl = (raw) => {
-    const marks = [];
-    for (const line of raw.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (parsed.type && parsed.type !== "word")
-                continue;
-            const time = asFiniteNumber(parsed.time);
-            const start = asFiniteNumber(parsed.start);
-            const end = asFiniteNumber(parsed.end);
-            if (time === null || start === null || end === null)
-                continue;
-            const value = typeof parsed.value === "string" ? parsed.value : "";
-            marks.push({
-                time,
-                type: "word",
-                start,
-                end,
-                value,
-            });
-        }
-        catch {
-            // Ignore malformed JSONL rows while preserving valid marks.
-        }
-    }
-    return sortSpeechMarks(marks);
-};
-const normalizeMarkTimeUnits = (marks) => {
-    if (marks.length < 2)
-        return marks;
-    const times = marks.map((mark) => mark.time).filter((time) => time >= 0);
-    const maxTime = times.length ? Math.max(...times) : 0;
-    const deltas = [];
-    for (let index = 1; index < times.length; index += 1) {
-        const delta = times[index] - times[index - 1];
-        if (delta > 0 && Number.isFinite(delta))
-            deltas.push(delta);
-    }
-    const medianDelta = deltas.length > 0
-        ? [...deltas].sort((a, b) => a - b)[Math.floor(deltas.length / 2)]
-        : 0;
-    const shapeSuggestsSeconds = (maxTime > 0 && maxTime < 100 && marks.length > 3) ||
-        (medianDelta > 0 && medianDelta < 10);
-    if (!shapeSuggestsSeconds)
-        return marks;
-    return marks.map((mark) => ({ ...mark, time: mark.time * 1000 }));
-};
-const estimateOffsetShift = (marks, requestText) => {
-    if (!marks.length || !requestText.length)
-        return 0;
-    const textLower = requestText.toLowerCase();
-    const candidates = [];
-    let cursor = 0;
-    for (const mark of marks) {
-        const token = mark.value.trim().toLowerCase();
-        if (!token)
-            continue;
-        const found = textLower.indexOf(token, cursor);
-        if (found < 0)
-            continue;
-        const delta = mark.start - found;
-        if (delta >= 0)
-            candidates.push(delta);
-        cursor = found + token.length;
-        if (candidates.length >= 8)
-            break;
-    }
-    if (candidates.length > 0) {
-        const ordered = [...candidates].sort((a, b) => a - b);
-        return ordered[Math.floor(ordered.length / 2)];
-    }
-    return Math.max(0, Math.floor(marks[0].start));
-};
-const rebaseOffsetsToRequestText = (marks, requestText) => {
-    if (!marks.length || !requestText.length)
-        return marks;
-    const textLength = requestText.length;
-    const maxEnd = Math.max(...marks.map((mark) => mark.end));
-    if (maxEnd <= textLength + 2)
-        return marks;
-    const shift = estimateOffsetShift(marks, requestText);
-    if (shift <= 0)
-        return marks;
-    return marks.map((mark) => ({
-        ...mark,
-        start: mark.start - shift,
-        end: mark.end - shift,
-    }));
-};
-const clampMarkRanges = (marks, requestText) => {
-    if (!requestText.length)
-        return marks;
-    const textLength = requestText.length;
-    return sortSpeechMarks(marks.map((mark) => {
-        const start = Math.max(0, Math.min(textLength, Math.floor(mark.start)));
-        const end = Math.max(start + 1, Math.min(textLength, Math.floor(mark.end)));
-        return { ...mark, start, end };
-    }));
-};
-const normalizeSpeechMarks = (raw, requestText) => {
-    const parsed = parseWordMarksJsonl(raw);
-    const withTimes = normalizeMarkTimeUnits(parsed);
-    const rebased = rebaseOffsetsToRequestText(withTimes, requestText);
-    return clampMarkRanges(rebased, requestText);
-};
 export class SchoolCityServerProvider extends BaseTTSProvider {
     providerId = "schoolcity-tts";
     providerName = "SchoolCity TTS";
@@ -467,7 +344,7 @@ export class SchoolCityServerProvider extends BaseTTSProvider {
             });
             const body = (await parseResponseBody(response));
             if (!response.ok) {
-                throw new TTSError(TTSErrorCode.PROVIDER_ERROR, typeof body.message === "string"
+                throw new TTSError(resolveTTSErrorCodeForHttpStatus(response.status), typeof body.message === "string"
                     ? body.message
                     : `SchoolCity synthesis failed (${response.status})`, { status: response.status, body }, this.providerId);
             }
@@ -512,7 +389,7 @@ export class SchoolCityServerProvider extends BaseTTSProvider {
                 const marksUrl = validateAssetUrl(word, this.config, this.baseUrl);
                 const marksResponse = await fetchAssetWithManualRedirects(marksUrl, this.config, this.baseUrl, this.fetchImpl, { signal: timeout.signal });
                 if (!marksResponse.ok) {
-                    throw new TTSError(TTSErrorCode.PROVIDER_ERROR, `SchoolCity marks fetch failed (${marksResponse.status})`, { word, status: marksResponse.status }, this.providerId);
+                    throw new TTSError(resolveTTSErrorCodeForHttpStatus(marksResponse.status), `SchoolCity marks fetch failed (${marksResponse.status})`, { word, status: marksResponse.status }, this.providerId);
                 }
                 const marksRaw = await marksResponse.text();
                 speechMarks = normalizeSpeechMarks(marksRaw, payload.text);
@@ -548,7 +425,7 @@ export class SchoolCityServerProvider extends BaseTTSProvider {
             audioTimeout.clear();
         }
         if (!audioResponse.ok) {
-            throw new TTSError(TTSErrorCode.PROVIDER_ERROR, `Failed to fetch SchoolCity audio asset (${audioResponse.status})`, { audioContent, status: audioResponse.status }, this.providerId);
+            throw new TTSError(resolveTTSErrorCodeForHttpStatus(audioResponse.status), `Failed to fetch SchoolCity audio asset (${audioResponse.status})`, { audioContent, status: audioResponse.status }, this.providerId);
         }
         const arrayBuffer = await audioResponse.arrayBuffer();
         const audio = Buffer.from(arrayBuffer);
@@ -566,9 +443,17 @@ export class SchoolCityServerProvider extends BaseTTSProvider {
             },
         };
     }
-    async getVoices(_options) {
+    /**
+     * The service's locale roster, from the table it reads itself.
+     *
+     * Not a network call: the service has no voice or locale endpoint to ask, so
+     * `sc-voices.ts` transcribes the map behind `POST /` instead. Returning `[]`,
+     * as this did, left the 29 locales reachable only by a caller that already
+     * knew a `lang_id` to hardcode.
+     */
+    async getVoices(options) {
         this.ensureInitialized();
-        return [];
+        return schoolCityVoices(options);
     }
     getCapabilities() {
         return {

package/dist/index.d.ts

@@ -4,3 +4,5 @@
  */
 export type { SchoolCityProviderConfig, SchoolCitySynthesizeAssetsResult, } from "./SchoolCityServerProvider.js";
 export { SchoolCityServerProvider } from "./SchoolCityServerProvider.js";
+export type { SchoolCityVoiceEntry } from "./sc-voices.js";
+export { defaultVoiceForSchoolCityLanguage, isSupportedSchoolCityLanguage, SCHOOLCITY_DEFAULT_VOICES, schoolCityVoices, } from "./sc-voices.js";

package/dist/index.js

@@ -3,3 +3,4 @@
  * @module @pie-players/tts-server-sc
  */
 export { SchoolCityServerProvider } from "./SchoolCityServerProvider.js";
+export { defaultVoiceForSchoolCityLanguage, isSupportedSchoolCityLanguage, SCHOOLCITY_DEFAULT_VOICES, schoolCityVoices, } from "./sc-voices.js";

package/dist/sc-voices.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The locale roster the SchoolCity TTS service actually serves.
+ *
+ * The service is AWS Polly behind a two-route Fastify app, and it carries one
+ * default voice per locale in `src/helpers/voices.js`. That map is the source of
+ * truth transcribed here, and it does two jobs upstream: it supplies the
+ * `VoiceId` when a request omits `voice`, and it gates `lang_id` — an
+ * unrecognized `lang_id` is **silently rewritten to `en-US`** rather than
+ * refused, so a caller asking for an unserved locale gets English audio and no
+ * error. `isSupportedSchoolCityLanguage` exists so a caller can see that coming.
+ *
+ * Why a transcription rather than a lookup: the service exposes no voice or
+ * locale endpoint. `GET /ping` and an authenticated `POST /` are the whole
+ * surface, so there is nothing to query and this table is the only way a caller
+ * can learn which locales exist. The cost is that it goes stale silently if the
+ * service adds a locale — a deliberate trade, and the reason each entry is
+ * traceable to a single upstream line rather than derived.
+ *
+ * Only the *default* voice per locale is listed. The service accepts any
+ * `VoiceId` Polly knows, and `voices.js` names alternates for most locales in
+ * trailing comments, so a per-locale voice roster is reachable — but it would be
+ * assembled from hand-maintained comments rather than from the map the service
+ * reads, so it is left out.
+ */
+import type { GetVoicesOptions, Voice } from "@pie-players/tts-server-core";
+/** One locale the service serves, and the voice it speaks by default. */
+export interface SchoolCityVoiceEntry {
+    /** `lang_id` as the service spells it. */
+    readonly languageCode: string;
+    /**
+     * Display name, matching Polly's own `LanguageName` for the same voice so
+     * this provider and `tts-server-polly` agree on the label for one voice id.
+     */
+    readonly language: string;
+    /** Polly `VoiceId`, sent as `voice` when the caller names none. */
+    readonly voiceId: string;
+    /**
+     * Absent where the upstream map records no gender. `voices.js` annotates most
+     * locales with the female and male voices available, and two — `arb` and
+     * `cmn-CN` — carry no annotation at all. Inferring those from elsewhere would
+     * put a fact in this table that its source does not support, so they stay
+     * unset and a gender-filtered query does not return them.
+     */
+    readonly gender?: "male" | "female";
+}
+/**
+ * Transcribed from `sc-texttospeech-api/src/helpers/voices.js`, in upstream
+ * order. Genders come from that file's own trailing comments.
+ */
+export declare const SCHOOLCITY_DEFAULT_VOICES: readonly SchoolCityVoiceEntry[];
+/** The service's roster as `Voice` records, narrowed by `options`. */
+export declare const schoolCityVoices: (options?: GetVoicesOptions) => Voice[];
+/**
+ * Whether the service serves this locale, matched exactly as `lang_id` is.
+ *
+ * Worth checking before synthesis: an unserved `lang_id` is not an error
+ * upstream, it is English audio.
+ */
+export declare const isSupportedSchoolCityLanguage: (languageCode: string) => boolean;
+/** The `VoiceId` the service would choose for a locale, if it serves it. */
+export declare const defaultVoiceForSchoolCityLanguage: (languageCode: string) => string | undefined;

package/dist/sc-voices.js

@@ -0,0 +1,264 @@
+/**
+ * The locale roster the SchoolCity TTS service actually serves.
+ *
+ * The service is AWS Polly behind a two-route Fastify app, and it carries one
+ * default voice per locale in `src/helpers/voices.js`. That map is the source of
+ * truth transcribed here, and it does two jobs upstream: it supplies the
+ * `VoiceId` when a request omits `voice`, and it gates `lang_id` — an
+ * unrecognized `lang_id` is **silently rewritten to `en-US`** rather than
+ * refused, so a caller asking for an unserved locale gets English audio and no
+ * error. `isSupportedSchoolCityLanguage` exists so a caller can see that coming.
+ *
+ * Why a transcription rather than a lookup: the service exposes no voice or
+ * locale endpoint. `GET /ping` and an authenticated `POST /` are the whole
+ * surface, so there is nothing to query and this table is the only way a caller
+ * can learn which locales exist. The cost is that it goes stale silently if the
+ * service adds a locale — a deliberate trade, and the reason each entry is
+ * traceable to a single upstream line rather than derived.
+ *
+ * Only the *default* voice per locale is listed. The service accepts any
+ * `VoiceId` Polly knows, and `voices.js` names alternates for most locales in
+ * trailing comments, so a per-locale voice roster is reachable — but it would be
+ * assembled from hand-maintained comments rather than from the map the service
+ * reads, so it is left out.
+ */
+/**
+ * Transcribed from `sc-texttospeech-api/src/helpers/voices.js`, in upstream
+ * order. Genders come from that file's own trailing comments.
+ */
+export const SCHOOLCITY_DEFAULT_VOICES = [
+    { languageCode: "arb", language: "Arabic", voiceId: "Zeina" },
+    { languageCode: "cmn-CN", language: "Chinese Mandarin", voiceId: "Zhiyu" },
+    {
+        languageCode: "da-DK",
+        language: "Danish",
+        voiceId: "Naja",
+        gender: "female",
+    },
+    {
+        languageCode: "nl-NL",
+        language: "Dutch",
+        voiceId: "Lotte",
+        gender: "female",
+    },
+    {
+        languageCode: "en-AU",
+        language: "Australian English",
+        voiceId: "Nicole",
+        gender: "female",
+    },
+    {
+        languageCode: "en-GB",
+        language: "British English",
+        voiceId: "Amy",
+        gender: "female",
+    },
+    {
+        languageCode: "en-IN",
+        language: "Indian English",
+        voiceId: "Aditi",
+        gender: "female",
+    },
+    {
+        languageCode: "en-US",
+        language: "US English",
+        voiceId: "Salli",
+        gender: "female",
+    },
+    {
+        languageCode: "en-GB-WLS",
+        language: "Welsh English",
+        voiceId: "Geraint",
+        gender: "male",
+    },
+    {
+        languageCode: "fr-FR",
+        language: "French",
+        voiceId: "Mathieu",
+        gender: "male",
+    },
+    {
+        languageCode: "fr-CA",
+        language: "Canadian French",
+        voiceId: "Chantal",
+        gender: "female",
+    },
+    {
+        languageCode: "de-DE",
+        language: "German",
+        voiceId: "Vicki",
+        gender: "female",
+    },
+    {
+        languageCode: "hi-IN",
+        language: "Hindi",
+        voiceId: "Aditi",
+        gender: "female",
+    },
+    {
+        languageCode: "is-IS",
+        language: "Icelandic",
+        voiceId: "Dora",
+        gender: "female",
+    },
+    {
+        languageCode: "it-IT",
+        language: "Italian",
+        voiceId: "Bianca",
+        gender: "female",
+    },
+    {
+        languageCode: "ja-JP",
+        language: "Japanese",
+        voiceId: "Mizuki",
+        gender: "female",
+    },
+    {
+        languageCode: "ko-KR",
+        language: "Korean",
+        voiceId: "Seoyeon",
+        gender: "female",
+    },
+    {
+        languageCode: "nb-NO",
+        language: "Norwegian",
+        voiceId: "Liv",
+        gender: "female",
+    },
+    {
+        languageCode: "pl-PL",
+        language: "Polish",
+        voiceId: "Ewa",
+        gender: "female",
+    },
+    {
+        languageCode: "pt-BR",
+        language: "Brazilian Portuguese",
+        voiceId: "Vitoria",
+        gender: "female",
+    },
+    {
+        languageCode: "pt-PT",
+        language: "Portuguese",
+        voiceId: "Ines",
+        gender: "female",
+    },
+    {
+        languageCode: "ro-RO",
+        language: "Romanian",
+        voiceId: "Carmen",
+        gender: "female",
+    },
+    {
+        languageCode: "ru-RU",
+        language: "Russian",
+        voiceId: "Tatyana",
+        gender: "female",
+    },
+    {
+        languageCode: "es-ES",
+        language: "Castilian Spanish",
+        voiceId: "Conchita",
+        gender: "female",
+    },
+    {
+        languageCode: "es-MX",
+        language: "Mexican Spanish",
+        voiceId: "Mia",
+        gender: "female",
+    },
+    {
+        languageCode: "es-US",
+        language: "US Spanish",
+        voiceId: "Miguel",
+        gender: "male",
+    },
+    {
+        languageCode: "sv-SE",
+        language: "Swedish",
+        voiceId: "Astrid",
+        gender: "female",
+    },
+    {
+        languageCode: "tr-TR",
+        language: "Turkish",
+        voiceId: "Filiz",
+        gender: "female",
+    },
+    {
+        languageCode: "cy-GB",
+        language: "Welsh",
+        voiceId: "Gwyneth",
+        gender: "female",
+    },
+];
+/**
+ * Every voice the service serves is a Polly *standard* voice: no `Engine` is
+ * ever sent on the synthesis call, and standard is Polly's default.
+ */
+const SCHOOLCITY_VOICE_QUALITY = "standard";
+const normalizeTag = (tag) => tag.trim().toLowerCase().replace(/_/g, "-");
+/**
+ * RFC 4647 basic filtering: a range matches a tag it equals, or a tag it prefixes
+ * at a subtag boundary. So `en` reaches every English locale and `en-GB` reaches
+ * `en-GB-WLS`, while `en-G` reaches nothing.
+ */
+const languageMatches = (languageCode, filter) => {
+    const tag = normalizeTag(languageCode);
+    const range = normalizeTag(filter);
+    if (!range)
+        return true;
+    return tag === range || tag.startsWith(`${range}-`);
+};
+const toVoice = (entry) => ({
+    // The service identifies a voice by its Polly `VoiceId`, and that is what a
+    // caller passes back as `SynthesizeRequest.voice`.
+    id: entry.voiceId,
+    name: entry.voiceId,
+    language: entry.language,
+    languageCode: entry.languageCode,
+    ...(entry.gender ? { gender: entry.gender } : {}),
+    quality: SCHOOLCITY_VOICE_QUALITY,
+    supportedFeatures: {
+        // The service always sends `TextType: "ssml"`, so SSML is not optional here.
+        ssml: true,
+        emotions: false,
+        styles: false,
+    },
+    providerMetadata: {
+        /** This is the voice the service picks for the locale when none is named. */
+        isServiceDefault: true,
+    },
+});
+/** The service's roster as `Voice` records, narrowed by `options`. */
+export const schoolCityVoices = (options) => {
+    // Every entry is standard, so any other quality asks for a voice the service
+    // cannot produce.
+    if (options?.quality && options.quality !== SCHOOLCITY_VOICE_QUALITY) {
+        return [];
+    }
+    return SCHOOLCITY_DEFAULT_VOICES.filter((entry) => {
+        if (options?.language &&
+            !languageMatches(entry.languageCode, options.language)) {
+            return false;
+        }
+        if (options?.gender && entry.gender !== options.gender)
+            return false;
+        return true;
+    }).map(toVoice);
+};
+/**
+ * Whether the service serves this locale, matched exactly as `lang_id` is.
+ *
+ * Worth checking before synthesis: an unserved `lang_id` is not an error
+ * upstream, it is English audio.
+ */
+export const isSupportedSchoolCityLanguage = (languageCode) => {
+    const tag = normalizeTag(languageCode);
+    return SCHOOLCITY_DEFAULT_VOICES.some((entry) => normalizeTag(entry.languageCode) === tag);
+};
+/** The `VoiceId` the service would choose for a locale, if it serves it. */
+export const defaultVoiceForSchoolCityLanguage = (languageCode) => {
+    const tag = normalizeTag(languageCode);
+    return SCHOOLCITY_DEFAULT_VOICES.find((entry) => normalizeTag(entry.languageCode) === tag)?.voiceId;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pie-players/tts-server-sc",
-	"version": "0.3.67",
+	"version": "0.3.68",
 	"description": "SchoolCity-backed provider for server-side TTS with speech marks support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -38,7 +38,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@pie-players/tts-server-core": "0.3.67",
+		"@pie-players/tts-server-core": "0.3.68",
 		"jose": "^6.2.8",
 		"tldts": "^7.0.26"
 	},