@drakulavich/kesha-voice-kit 2.0.0 → 2.2.0-beta.1

package/src/support-bundle.ts

@@ -1,8 +1,11 @@
-import { existsSync, mkdirSync, statSync, writeFileSync } from "fs";
-import { basename, dirname, resolve } from "path";
+import { lstatSync, mkdirSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
 import { gzipSync } from "node:zlib";
 import { collectDoctorReport, formatDoctorReport } from "./doctor";
 import { readDiagnosticLogTail } from "./diagnostic-log";
+import { KeshaError } from "./engine/events";
+import { errorMessage } from "./error-utils";
+import { PATH_ERRNOS } from "./path-errnos";
 
 interface SupportBundleOptions {
   output?: string;
@@ -99,6 +102,67 @@ function createTarArchive(entries: TarEntry[]): Uint8Array {
   return archive;
 }
 
+function existsAsLink(path: string): boolean {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function fileInTheWay(dir: string): string | null {
+  for (let d = dir; ; d = dirname(d)) {
+    try {
+      return statSync(d).isDirectory() ? null : d;
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code === "ENOENT" && existsAsLink(d)) return d;
+      if (dirname(d) === d) return null;
+    }
+  }
+}
+
+function mkdirReason(dir: string, errno: string): string {
+  if (errno !== "EEXIST") return errno;
+  try {
+    statSync(dir);
+    return errno;
+  } catch (e) {
+    return (e as NodeJS.ErrnoException).code ?? errno;
+  }
+}
+
+function bundleWriteFailure(outputPath: string, e: unknown): unknown {
+  if ((e as NodeJS.ErrnoException).code === "EPIPE") return e;
+  const dir = dirname(outputPath);
+  const errno = mkdirReason(dir, (e as NodeJS.ErrnoException).code ?? "");
+  const blocker = fileInTheWay(dir);
+  if (blocker) {
+    return new KeshaError("E_INVALID_ARG", `Cannot write the support bundle to ${outputPath}: ${blocker} exists and is not a directory`, {
+      hint: `remove or rename the file blocking ${blocker}, or pass --output a path under a directory.`,
+    });
+  }
+  if (errno === "EISDIR") {
+    return new KeshaError("E_INVALID_ARG", `Cannot write the support bundle to ${outputPath}: it is a directory (EISDIR)`, {
+      hint: `pass --output a .tar.gz file path, for example ${join(outputPath, "kesha-support-bundle.tar.gz")}.`,
+    });
+  }
+  const why = PATH_ERRNOS[errno];
+  if (why) {
+    return new KeshaError("E_INVALID_ARG", `Cannot write the support bundle to ${outputPath}: ${why} (${errno})`, {
+      hint: `pass --output a path in a directory you can write to.`,
+    });
+  }
+  if (!errno) return e;
+  if (errno === "ENOSPC") {
+    return new KeshaError("E_INTERNAL", `Cannot write the support bundle to ${outputPath}: no space left on its disk (ENOSPC)`, {
+      hint: `the disk is full: free space on the volume that holds ${dir}, or pass --output a path on another disk.`,
+    });
+  }
+  return new KeshaError("E_INTERNAL", `Cannot write the support bundle to ${outputPath}: ${errorMessage(e)}`, {
+    hint: `resolve that filesystem error on ${dir}, or pass --output a path elsewhere.`,
+  });
+}
+
 export async function createSupportBundle(
   options: SupportBundleOptions = {},
 ): Promise<SupportBundleResult> {
@@ -180,16 +244,17 @@ export async function createSupportBundle(
     );
   }
 
-  mkdirSync(dirname(outputPath), { recursive: true });
-  writeFileSync(outputPath, gzipSync(createTarArchive(files)));
-
-  if (!existsSync(outputPath)) {
-    throw new Error(`failed to create support bundle: ${outputPath}`);
+  const archive = gzipSync(createTarArchive(files));
+  try {
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, archive);
+  } catch (e) {
+    throw bundleWriteFailure(outputPath, e);
   }
 
   return {
     path: outputPath,
-    sizeBytes: statSync(outputPath).size,
+    sizeBytes: archive.byteLength,
     entries: files.map((file) => file.name),
   };
 }

package/src/toon.ts

@@ -15,5 +15,6 @@ export function formatToonOutput<T extends object, E extends object>(
   results: T[],
   errors?: E[],
 ): string {
-  return encodeToon(errors === undefined ? results : { results, errors }) + "\n";
+  const payload = errors === undefined ? results : { results, errors };
+  return encodeToon(JSON.parse(JSON.stringify(payload))) + "\n";
 }

package/src/voice-routing.ts

@@ -1,4 +1,4 @@
-import { detectTextLanguageEngine } from "./engine";
+import { detectTextLanguageEngine, type LangDetectResult } from "./engine";
 import { listVoiceIds } from "./synth";
 
 /** The voice the Engine speaks with when `say` is given no `--voice` — mirrors `tts::voices::DEFAULT_VOICE_ID`. */
@@ -63,6 +63,12 @@ const NATIVE_SCRIPT_ROUTES: Record<string, NativeScriptRoute> = {
 };
 
 const LATIN_LETTER = /[A-Za-z]/u;
+const CYRILLIC = /\p{Script=Cyrillic}/u;
+
+function mostlyCyrillicWords(text: string): boolean {
+  const words = text.split(/\s+/).filter((w) => /\p{L}/u.test(w));
+  return words.filter((w) => CYRILLIC.test(w)).length * 2 > words.length;
+}
 
 /** True when more of the text's letters are in `script` than in the Latin alphabet. */
 function dominantScript(text: string, script: RegExp): boolean {
@@ -110,6 +116,7 @@ export interface ResolveSayVoiceOptions {
   arch?: NodeJS.Architecture;
   /** The engine's `say --list-voices` union; injected so the routing decision is testable without an engine. */
   listVoices?: (signal?: AbortSignal) => Promise<string[]>;
+  detectLanguage?: (text: string, signal?: AbortSignal) => Promise<LangDetectResult | null>;
 }
 
 function baseLangOf(code: string | undefined): string {
@@ -145,7 +152,9 @@ async function detectLang(
   options: ResolveSayVoiceOptions,
 ): Promise<{ code?: string; confidence: number }> {
   if (!text) return { confidence: 0 };
-  const detected = await detectTextLanguageEngine(text, { signal: options.signal });
+  const detected = options.detectLanguage
+    ? await options.detectLanguage(text, options.signal)
+    : await detectTextLanguageEngine(text, { signal: options.signal });
   return { code: detected?.code, confidence: detected?.confidence ?? 0 };
 }
 
@@ -153,7 +162,8 @@ async function detectLang(
  * Resolve the voice for a synthesis request. Precedence: explicit voice >
  * explicit language hint (route by the stated language, skipping detection —
  * also the path on Linux/Windows where text-language detection is unavailable) >
- * macOS text-language auto-detection > engine default (`undefined`). A language
+ * macOS text-language auto-detection > Russian when detection is inconclusive and most
+ * words are Cyrillic (#1387) > engine default (`undefined`). A language
  * hint the build has no voice for resolves to `undefined` (engine default)
  * rather than re-running detection — the user stated the language explicitly.
  *
@@ -170,6 +180,9 @@ export async function resolveSayVoice(
   const { code, confidence } =
     langHint !== undefined ? { code: langHint, confidence: 1 } : await detectLang(text, options);
   const voice = pickVoiceForLang(code, confidence, options.platform, options.arch);
+  if (confidence < 0.5 && mostlyCyrillicWords(text)) {
+    return pickVoiceForLang("ru", 1, options.platform, options.arch);
+  }
   if (confidence < 0.5) return voice;
   return (await nativeScriptOverride(baseLangOf(code), text, options)) ?? voice;
 }