yt2text 0.1.0

package/dist/cookies.js

@@ -0,0 +1,121 @@
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+const candidates = [
+    {
+        id: "chrome",
+        name: "Google Chrome",
+        macApps: ["Google Chrome.app"],
+        commands: ["google-chrome", "google-chrome-stable", "chrome"],
+        windowsPaths: [
+            "Google\\Chrome\\Application\\chrome.exe",
+        ],
+    },
+    {
+        id: "safari",
+        name: "Safari",
+        macApps: ["Safari.app"],
+    },
+    {
+        id: "firefox",
+        name: "Firefox",
+        macApps: ["Firefox.app"],
+        commands: ["firefox"],
+        windowsPaths: [
+            "Mozilla Firefox\\firefox.exe",
+        ],
+    },
+    {
+        id: "edge",
+        name: "Microsoft Edge",
+        macApps: ["Microsoft Edge.app"],
+        commands: ["microsoft-edge", "microsoft-edge-stable"],
+        windowsPaths: [
+            "Microsoft\\Edge\\Application\\msedge.exe",
+        ],
+    },
+    {
+        id: "brave",
+        name: "Brave",
+        macApps: ["Brave Browser.app"],
+        commands: ["brave-browser", "brave"],
+        windowsPaths: [
+            "BraveSoftware\\Brave-Browser\\Application\\brave.exe",
+        ],
+    },
+    {
+        id: "chromium",
+        name: "Chromium",
+        macApps: ["Chromium.app"],
+        commands: ["chromium", "chromium-browser"],
+    },
+];
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function commandExists(command) {
+    const paths = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    const suffixes = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+    for (const dir of paths) {
+        for (const suffix of suffixes) {
+            if (await exists(join(dir, `${command}${suffix}`)))
+                return true;
+        }
+    }
+    return false;
+}
+async function hasMacApp(candidate) {
+    for (const app of candidate.macApps ?? []) {
+        if (await exists(join("/Applications", app)))
+            return true;
+        if (await exists(join(homedir(), "Applications", app)))
+            return true;
+    }
+    return false;
+}
+async function hasWindowsApp(candidate) {
+    const roots = [
+        process.env.LOCALAPPDATA,
+        process.env.PROGRAMFILES,
+        process.env["PROGRAMFILES(X86)"],
+    ].filter(Boolean);
+    for (const relative of candidate.windowsPaths ?? []) {
+        for (const root of roots) {
+            if (await exists(join(root, relative)))
+                return true;
+        }
+    }
+    return false;
+}
+async function isInstalled(candidate) {
+    if (process.platform === "darwin")
+        return hasMacApp(candidate);
+    if (process.platform === "win32")
+        return hasWindowsApp(candidate);
+    for (const command of candidate.commands ?? []) {
+        if (await commandExists(command))
+            return true;
+    }
+    return false;
+}
+export function defaultCookiesFromBrowser() {
+    return process.platform === "darwin" ? "auto" : undefined;
+}
+export function knownCookieBrowsers() {
+    return candidates.map(({ id, name }) => ({ id, name }));
+}
+export async function detectCookieBrowsers() {
+    const detected = [];
+    for (const candidate of candidates) {
+        if (await isInstalled(candidate)) {
+            detected.push({ id: candidate.id, name: candidate.name });
+        }
+    }
+    return detected;
+}

package/dist/deps.js

@@ -0,0 +1,82 @@
+import { access, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { downloadFile } from "./download-file.js";
+import { executableName, ytdlpReleaseUrl } from "./platform.js";
+import { runCommand } from "./process.js";
+import { asError, Yt2TextError } from "./errors.js";
+const require = createRequire(import.meta.url);
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function commandExists(command) {
+    try {
+        await runCommand(command, ["--version"], { quiet: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureYtDlp(paths, options) {
+    const localPath = join(paths.toolsDir, executableName("yt-dlp"));
+    if ((await exists(localPath)) && !options.updateYtDlp)
+        return localPath;
+    if ((await commandExists("yt-dlp")) && !options.updateYtDlp)
+        return "yt-dlp";
+    if (options.offline) {
+        throw new Yt2TextError("yt-dlp is not cached and --offline was set", "MISSING_DEPENDENCY");
+    }
+    if (options.updateYtDlp) {
+        await rm(localPath, { force: true });
+    }
+    console.error(`Downloading yt-dlp to ${localPath}`);
+    await downloadFile(ytdlpReleaseUrl(), localPath, "Downloading yt-dlp");
+    return localPath;
+}
+export async function getFfmpegPath() {
+    try {
+        const ffmpeg = require("@ffmpeg-installer/ffmpeg");
+        if (ffmpeg.path)
+            return ffmpeg.path;
+    }
+    catch {
+        // Fall through to PATH.
+    }
+    if (await commandExists("ffmpeg"))
+        return "ffmpeg";
+    throw new Yt2TextError("ffmpeg was not found", "MISSING_DEPENDENCY");
+}
+export async function ensureMacosSwiftc(options) {
+    if (process.platform !== "darwin")
+        return;
+    if (await commandExists("swiftc"))
+        return;
+    if (options.offline) {
+        throw new Yt2TextError("swiftc is missing and --offline was set", "MISSING_DEPENDENCY");
+    }
+    console.error("Xcode Command Line Tools are required for macOS system ASR. Opening Apple's installer...");
+    try {
+        await runCommand("xcode-select", ["--install"], { quiet: true });
+    }
+    catch (error) {
+        const message = asError(error).message;
+        const lower = message.toLowerCase();
+        const installerAlreadyActive = lower.includes("install requested") ||
+            lower.includes("already installed") ||
+            lower.includes("software update") ||
+            lower.includes("currently being installed");
+        if (!installerAlreadyActive) {
+            throw new Yt2TextError(`Could not start Xcode Command Line Tools installer.\n${message}\n\nRun manually: xcode-select --install`, "MISSING_DEPENDENCY");
+        }
+    }
+    if (await commandExists("swiftc"))
+        return;
+    throw new Yt2TextError("Xcode Command Line Tools installer was opened. Finish the macOS installation, then rerun yt2text.", "MISSING_DEPENDENCY");
+}

package/dist/doctor.js

@@ -0,0 +1,140 @@
+import { access } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { detectCookieBrowsers } from "./cookies.js";
+import { commandExists, ensureMacosSwiftc, ensureYtDlp, getFfmpegPath } from "./deps.js";
+import { defaultAsrProvider, executableName, isSupportedPlatform, platformName } from "./platform.js";
+import { runCommand } from "./process.js";
+const require = createRequire(import.meta.url);
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function commandVersion(command) {
+    try {
+        return (await runCommand(command, ["--version"], { quiet: true })).stdout.trim().split(/\r?\n/)[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+function packageInstalled(name) {
+    try {
+        require.resolve(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function redactUrl(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        if (url.password)
+            url.password = "****";
+        return url.toString();
+    }
+    catch {
+        return value;
+    }
+}
+function effectiveOptions(options, paths) {
+    return {
+        configPath: options.configPath,
+        asr: options.asr,
+        systemMode: options.systemMode,
+        fallback: options.fallback,
+        language: options.language,
+        model: options.model,
+        diarize: options.diarize,
+        format: options.format,
+        outputDir: options.outputDir,
+        cacheDir: paths.cacheDir,
+        offline: options.offline,
+        keepAudio: options.keepAudio,
+        keepOriginalAudio: options.keepOriginalAudio,
+        chunkSeconds: options.chunkSeconds,
+        filenameTemplate: options.filenameTemplate,
+        audioQuality: options.audioQuality,
+        browserCookies: options.browserCookies,
+        cookiesFromBrowser: options.cookiesFromBrowser,
+        cookies: options.cookies,
+        concurrentFragments: options.concurrentFragments,
+        retries: options.retries,
+        fragmentRetries: options.fragmentRetries,
+        socketTimeout: options.socketTimeout,
+        downloadTimeoutSeconds: options.downloadTimeoutSeconds,
+        convertTimeoutSeconds: options.convertTimeoutSeconds,
+        asrChunkTimeoutSeconds: options.asrChunkTimeoutSeconds,
+        proxy: redactUrl(options.proxy),
+        rateLimit: options.rateLimit,
+        userAgent: options.userAgent,
+        logFile: options.logFile,
+        updateYtDlp: options.updateYtDlp,
+    };
+}
+export async function runDoctor(paths, options, fix = false, showConfig = false) {
+    console.log(`Platform: ${platformName()} (${process.platform}/${process.arch})`);
+    console.log(`Supported: ${isSupportedPlatform() ? "yes" : "no; macOS, Linux, and Windows only"}`);
+    console.log(`Node: ${process.version}`);
+    console.log(`Config: ${options.configPath}`);
+    console.log(`Output: ${options.outputDir}`);
+    console.log(`Default ASR: ${isSupportedPlatform() ? defaultAsrProvider() : "unsupported"}`);
+    console.log(`Cache: ${paths.cacheDir}`);
+    const cachedYtDlp = join(paths.toolsDir, executableName("yt-dlp"));
+    const ytdlpCached = await exists(cachedYtDlp);
+    const ytdlpOnPath = await commandExists("yt-dlp");
+    const ytdlpPath = ytdlpCached ? cachedYtDlp : ytdlpOnPath ? "yt-dlp" : undefined;
+    console.log(`yt-dlp: ${ytdlpPath ?? "missing"}`);
+    if (ytdlpPath) {
+        const version = await commandVersion(ytdlpPath);
+        if (version)
+            console.log(`yt-dlp version: ${version}`);
+    }
+    if (fix && !ytdlpPath) {
+        console.log("yt-dlp: downloading");
+        await ensureYtDlp(paths, options);
+    }
+    try {
+        console.log(`ffmpeg: ${await getFfmpegPath()}`);
+    }
+    catch {
+        console.log("ffmpeg: missing");
+    }
+    console.log(`tar: ${(await commandExists("tar")) ? "PATH" : "missing; needed for local ASR model archives"}`);
+    console.log(`sherpa-onnx-node: ${packageInstalled("sherpa-onnx-node") ? "installed" : "missing optional dependency"}`);
+    const browsers = await detectCookieBrowsers();
+    console.log(`browser cookies: ${browsers.length ? browsers.map((browser) => `${browser.name} (${browser.id})`).join(", ") : "none detected"}`);
+    if (process.platform === "darwin") {
+        console.log("system ASR: macOS Speech.framework helper");
+        const hasSwiftc = await commandExists("swiftc");
+        console.log(`swiftc: ${hasSwiftc ? "PATH" : "missing; Xcode Command Line Tools required"}`);
+        if (fix && !hasSwiftc) {
+            await ensureMacosSwiftc(options);
+        }
+    }
+    else if (process.platform === "win32") {
+        console.log("system ASR: Windows SAPI helper (offline; untested)");
+        console.log(`powershell.exe: ${(await commandExists("powershell.exe")) ? "PATH" : "missing"}`);
+    }
+    else if (process.platform === "linux") {
+        console.log("system ASR: unavailable; local ASR is the default");
+    }
+    else {
+        console.log("system ASR: unsupported platform");
+    }
+    const localModel = join(paths.modelsDir, `sherpa-onnx-whisper-${options.model}`);
+    console.log(`local ASR model (${options.model}): ${(await exists(localModel)) ? "cached" : "not cached"}`);
+    console.log(`diarization: ${(await exists(join(paths.modelsDir, "sherpa-onnx-pyannote-segmentation-3-0"))) ? "cached" : "not cached"}`);
+    if (showConfig) {
+        console.log("Effective options:");
+        console.log(JSON.stringify(effectiveOptions(options, paths), null, 2));
+    }
+}

package/dist/download-file.js

@@ -0,0 +1,42 @@
+import { createWriteStream } from "node:fs";
+import { chmod, mkdir, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { Yt2TextError } from "./errors.js";
+import { ProgressBar } from "./progress.js";
+export async function downloadFile(url, destination, label) {
+    await mkdir(dirname(destination), { recursive: true });
+    const tmp = `${destination}.tmp`;
+    const response = await fetch(url, {
+        headers: { "user-agent": "yt2text/0.1" },
+        redirect: "follow",
+    });
+    if (!response.ok || !response.body) {
+        throw new Yt2TextError(`Failed to download ${url}: HTTP ${response.status}`, "DOWNLOAD_FAILED");
+    }
+    await rm(tmp, { force: true });
+    const totalHeader = response.headers.get("content-length");
+    const total = totalHeader ? Number(totalHeader) : undefined;
+    let downloaded = 0;
+    const progress = new ProgressBar(label ?? "Downloading file");
+    const meter = new Transform({
+        transform(chunk, _encoding, callback) {
+            downloaded += chunk.length;
+            progress.updateBytes(downloaded, total);
+            callback(null, chunk);
+        },
+    });
+    try {
+        await pipeline(Readable.fromWeb(response.body), meter, createWriteStream(tmp));
+        progress.finish();
+    }
+    catch (error) {
+        progress.fail();
+        throw error;
+    }
+    await rename(tmp, destination);
+    if (process.platform !== "win32") {
+        await chmod(destination, 0o755);
+    }
+}

package/dist/errors.js

@@ -0,0 +1,68 @@
+export class Yt2TextError extends Error {
+    code;
+    constructor(message, code = "YT2TEXT_ERROR") {
+        super(message);
+        this.code = code;
+    }
+}
+export function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+export function explainError(error) {
+    const err = asError(error);
+    const message = err.message;
+    const lower = message.toLowerCase();
+    const hints = [];
+    if (lower.includes("could not find") && lower.includes("cookies")) {
+        hints.push("Cookie 读取失败：确认浏览器已安装并登录 YouTube，或改用 --cookies <file> 指定 cookies.txt。");
+    }
+    if (lower.includes("permission") && lower.includes("cookies")) {
+        hints.push("Cookie 权限失败：关闭浏览器后重试，或导出 cookies.txt 后用 --cookies 指定。");
+    }
+    if (lower.includes("database is locked") || (lower.includes("sqlite") && lower.includes("locked"))) {
+        hints.push("Cookie 数据库被浏览器锁定：完全退出浏览器后重试。");
+    }
+    if (lower.includes("sign in to confirm") || lower.includes("not a bot")) {
+        hints.push("YouTube 要求登录/验证：请使用 --cookies-from-browser chrome/safari/firefox，或在交互模式里选择浏览器 cookies。");
+    }
+    if (lower.includes("http error 403") || lower.includes("forbidden")) {
+        hints.push("下载被拒绝：先试浏览器 cookies；如果仍失败，运行 yt2text doctor 检查 yt-dlp，并可用 --update-ytdlp 更新下载器。");
+    }
+    if (lower.includes("yt-dlp") && lower.includes("not cached") && lower.includes("offline")) {
+        hints.push("当前是离线模式但 yt-dlp 尚未缓存：去掉 --offline 让工具自动下载依赖。");
+    }
+    if (lower.includes("ffmpeg was not found")) {
+        hints.push("ffmpeg 不可用：重新 npm install，或安装系统 ffmpeg 后重试。");
+    }
+    if (lower.includes("swiftc was not found")) {
+        hints.push("macOS 系统语音 helper 需要 Swift 编译器：yt2text 会自动尝试打开 Xcode Command Line Tools 安装器；安装完成后重试。");
+    }
+    if (lower.includes("xcode command line tools installer was opened")) {
+        hints.push("请在 macOS 弹出的安装窗口里完成 Xcode Command Line Tools 安装，完成后重新运行刚才的 yt2text 命令。");
+    }
+    if (lower.includes("xcode-select --install")) {
+        hints.push("如果自动打开失败，可手动运行 xcode-select --install。");
+    }
+    if (lower.includes("tar was not found") || lower.includes("could not extract")) {
+        hints.push("模型解压失败：需要系统 tar 支持 .tar.bz2；macOS/Linux 通常自带，Windows 建议安装 bsdtar/libarchive 或先用 --asr system。");
+    }
+    if (lower.includes("timed out after")) {
+        hints.push("任务超时：可以调大 --download-timeout、--convert-timeout 或 --asr-chunk-timeout；网络下载慢时也可设置 --proxy。");
+    }
+    if (lower.includes("input media file not found")) {
+        hints.push("本地文件路径不可读：确认当前目录，或使用绝对路径。");
+    }
+    if (lower.includes("invalid config")) {
+        hints.push("配置文件字段名、类型或枚举值不正确：运行 yt2text config --print 查看可用字段。");
+    }
+    if (lower.includes("enotfound") || lower.includes("econnreset") || lower.includes("etimedout")) {
+        hints.push("网络连接失败：检查代理/网络，或设置 --proxy；依赖和模型只在首次使用时下载。");
+    }
+    if (lower.includes("whisper") && lower.includes("not cached") && lower.includes("offline")) {
+        hints.push("本地 ASR 模型未缓存：去掉 --offline 让工具自动下载模型，或先运行一次 --multilingual。");
+    }
+    if (lower.includes("sherpa-onnx-node is not installed")) {
+        hints.push("本地 ASR 依赖缺失：重新运行 npm install，避免使用 --no-optional；也可以先用 --asr system。");
+    }
+    return hints.length > 0 ? `${message}\n\n${hints.map((hint) => `Hint: ${hint}`).join("\n")}` : message;
+}

package/dist/local-asr.js

@@ -0,0 +1,218 @@
+import { createRequire } from "node:module";
+import { access, mkdir, rm, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { downloadFile } from "./download-file.js";
+import { ProgressBar } from "./progress.js";
+import { runCommand } from "./process.js";
+import { asError, Yt2TextError } from "./errors.js";
+const require = createRequire(import.meta.url);
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function nonEmptyFile(path) {
+    try {
+        return (await stat(path)).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function extractTar(archive, outputDir) {
+    try {
+        await runCommand("tar", ["-xjf", archive, "-C", outputDir], { quiet: true });
+    }
+    catch (error) {
+        throw new Yt2TextError(`Could not extract ${archive}. Install a tar implementation with bzip2 support and retry.\n${asError(error).message}`, "EXTRACT_FAILED");
+    }
+}
+function modelFolder(model) {
+    return `sherpa-onnx-whisper-${model}`;
+}
+async function whisperModelReady(folder, model) {
+    return ((await nonEmptyFile(join(folder, `${model}-encoder.int8.onnx`))) &&
+        (await nonEmptyFile(join(folder, `${model}-decoder.int8.onnx`))) &&
+        (await nonEmptyFile(join(folder, `${model}-tokens.txt`))));
+}
+async function ensureWhisperModel(paths, options) {
+    const folder = join(paths.modelsDir, modelFolder(options.model));
+    if (await whisperModelReady(folder, options.model))
+        return folder;
+    if (options.offline) {
+        throw new Yt2TextError(`Whisper ${options.model} model is not cached and --offline was set`, "MISSING_MODEL");
+    }
+    if (await exists(folder)) {
+        console.error(`Removing incomplete local ASR model cache: ${folder}`);
+        await rm(folder, { recursive: true, force: true });
+    }
+    await mkdir(paths.modelsDir, { recursive: true });
+    const archive = join(paths.modelsDir, `${modelFolder(options.model)}.tar.bz2`);
+    const url = `https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/${modelFolder(options.model)}.tar.bz2`;
+    console.error(`Downloading local ASR model ${options.model}`);
+    await downloadFile(url, archive, `Downloading Whisper ${options.model}`);
+    await extractTar(archive, paths.modelsDir);
+    await rm(archive, { force: true });
+    if (!(await whisperModelReady(folder, options.model))) {
+        throw new Yt2TextError(`Downloaded Whisper ${options.model} model is incomplete`, "MISSING_MODEL");
+    }
+    return folder;
+}
+async function ensureVadModel(paths, options) {
+    const model = join(paths.modelsDir, "silero_vad.onnx");
+    if (await nonEmptyFile(model))
+        return model;
+    if (options.offline)
+        throw new Yt2TextError("VAD model is not cached and --offline was set", "MISSING_MODEL");
+    await downloadFile("https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad.onnx", model, "Downloading VAD model");
+    if (!(await nonEmptyFile(model)))
+        throw new Yt2TextError("Downloaded VAD model is empty", "MISSING_MODEL");
+    return model;
+}
+function loadSherpa() {
+    try {
+        return require("sherpa-onnx-node");
+    }
+    catch (error) {
+        throw new Yt2TextError("sherpa-onnx-node is not installed for this platform; reinstall without --no-optional or use --asr system.", "MISSING_DEPENDENCY");
+    }
+}
+function whisperLanguage(locale) {
+    const normalized = locale.trim().toLowerCase();
+    if (!normalized || normalized === "auto")
+        return undefined;
+    return normalized.split(/[-_]/)[0];
+}
+export async function transcribeWithLocal(wavPath, paths, options) {
+    const sherpa = loadSherpa();
+    const modelDir = await ensureWhisperModel(paths, options);
+    const vadModel = await ensureVadModel(paths, options);
+    const prefix = options.model;
+    const recognizer = new sherpa.OfflineRecognizer({
+        featConfig: { sampleRate: 16000, featureDim: 80 },
+        modelConfig: {
+            whisper: {
+                encoder: join(modelDir, `${prefix}-encoder.int8.onnx`),
+                decoder: join(modelDir, `${prefix}-decoder.int8.onnx`),
+                language: whisperLanguage(options.language),
+                task: "transcribe",
+            },
+            tokens: join(modelDir, `${prefix}-tokens.txt`),
+            numThreads: Math.max(1, Math.min(4, Math.floor((await import("node:os")).cpus().length / 2))),
+            provider: "cpu",
+            debug: 0,
+        },
+    });
+    const vad = new sherpa.Vad({
+        sileroVad: {
+            model: vadModel,
+            threshold: 0.5,
+            minSpeechDuration: 0.25,
+            minSilenceDuration: 0.5,
+            maxSpeechDuration: 15,
+            windowSize: 512,
+        },
+        sampleRate: 16000,
+        debug: false,
+        numThreads: 1,
+    }, 120);
+    const wave = sherpa.readWave(wavPath);
+    const segments = [];
+    const windowSize = vad.config.sileroVad.windowSize;
+    const progress = new ProgressBar("Transcribing audio");
+    const drain = () => {
+        while (!vad.isEmpty()) {
+            const segment = vad.front();
+            vad.pop();
+            const stream = recognizer.createStream();
+            stream.acceptWaveform({ samples: segment.samples, sampleRate: wave.sampleRate });
+            recognizer.decode(stream);
+            const result = recognizer.getResult(stream);
+            const text = String(result.text ?? "").trim();
+            if (!text)
+                continue;
+            const start = segment.start / wave.sampleRate;
+            segments.push({
+                start,
+                end: start + segment.samples.length / wave.sampleRate,
+                text,
+            });
+        }
+    };
+    try {
+        for (let offset = 0; offset < wave.samples.length; offset += windowSize) {
+            vad.acceptWaveform(wave.samples.subarray(offset, offset + windowSize));
+            drain();
+            progress.update(offset / wave.samples.length);
+        }
+        vad.flush();
+        drain();
+        progress.finish();
+    }
+    catch (error) {
+        progress.fail();
+        throw error;
+    }
+    return { engine: `sherpa-onnx-whisper-${options.model}`, segments };
+}
+export async function diarizeWithLocal(wavPath, paths, options) {
+    const sherpa = loadSherpa();
+    const segmentation = await ensureDiarizationSegmentation(paths, options);
+    const embedding = await ensureDiarizationEmbedding(paths, options);
+    const diarizer = new sherpa.OfflineSpeakerDiarization({
+        segmentation: { pyannote: { model: join(segmentation, "model.onnx") } },
+        embedding: { model: embedding },
+        clustering: { numClusters: -1, threshold: 0.5 },
+        minDurationOn: 0.2,
+        minDurationOff: 0.5,
+    });
+    const wave = sherpa.readWave(wavPath);
+    const raw = diarizer.process(wave.samples);
+    return raw.map((segment, index) => ({
+        start: Number(segment.start ?? segment.begin ?? 0),
+        end: Number(segment.end ?? segment.stop ?? 0),
+        speaker: normalizeSpeaker(segment.speaker ?? segment.label ?? segment.cluster ?? index),
+    }));
+}
+async function ensureDiarizationSegmentation(paths, options) {
+    const folder = join(paths.modelsDir, "sherpa-onnx-pyannote-segmentation-3-0");
+    if (await nonEmptyFile(join(folder, "model.onnx")))
+        return folder;
+    if (options.offline)
+        throw new Yt2TextError("Diarization segmentation model is not cached", "MISSING_MODEL");
+    if (await exists(folder)) {
+        console.error(`Removing incomplete diarization segmentation cache: ${folder}`);
+        await rm(folder, { recursive: true, force: true });
+    }
+    const archive = join(paths.modelsDir, `${basename(folder)}.tar.bz2`);
+    console.error("Downloading speaker diarization segmentation model");
+    await downloadFile("https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-segmentation-models/sherpa-onnx-pyannote-segmentation-3-0.tar.bz2", archive, "Downloading diarization segmentation");
+    await extractTar(archive, paths.modelsDir);
+    await rm(archive, { force: true });
+    if (!(await nonEmptyFile(join(folder, "model.onnx")))) {
+        throw new Yt2TextError("Downloaded diarization segmentation model is incomplete", "MISSING_MODEL");
+    }
+    return folder;
+}
+async function ensureDiarizationEmbedding(paths, options) {
+    const model = join(paths.modelsDir, "3dspeaker_speech_eres2net_base_sv_zh-cn_3dspeaker_16k.onnx");
+    if (await nonEmptyFile(model))
+        return model;
+    if (options.offline)
+        throw new Yt2TextError("Diarization embedding model is not cached", "MISSING_MODEL");
+    console.error("Downloading speaker diarization embedding model");
+    await downloadFile("https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-recongition-models/3dspeaker_speech_eres2net_base_sv_zh-cn_3dspeaker_16k.onnx", model, "Downloading diarization embedding");
+    if (!(await nonEmptyFile(model)))
+        throw new Yt2TextError("Downloaded diarization embedding model is empty", "MISSING_MODEL");
+    return model;
+}
+function normalizeSpeaker(value) {
+    const raw = String(value);
+    const match = raw.match(/\d+/);
+    const index = match ? Number(match[0]) + 1 : 1;
+    return `Speaker ${index}`;
+}