@kenkaiiii/gg-editor 0.1.0

package/dist/core/vision.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { clampScore, clampWhy, parseScoreResponse } from "./vision.js";
+describe("parseScoreResponse", () => {
+    it("parses a clean JSON array", () => {
+        const out = parseScoreResponse('[{"score":9,"why":"sharp eyes"},{"score":3,"why":"blurry"}]', 2);
+        expect(out).toEqual([
+            { score: 9, why: "sharp eyes" },
+            { score: 3, why: "blurry" },
+        ]);
+    });
+    it("unwraps an object containing the array", () => {
+        const out = parseScoreResponse('{"shots":[{"score":7,"why":"ok"}]}', 1);
+        expect(out).toEqual([{ score: 7, why: "ok" }]);
+    });
+    it("recovers from prose-wrapped JSON", () => {
+        const content = 'Sure! Here are the scores: [{"score":8,"why":"good"}] hope this helps';
+        const out = parseScoreResponse(content, 1);
+        expect(out).toEqual([{ score: 8, why: "good" }]);
+    });
+    it("pads missing entries to expected length", () => {
+        const out = parseScoreResponse('[{"score":5,"why":"x"}]', 3);
+        expect(out).toHaveLength(3);
+        expect(out[0]).toEqual({ score: 5, why: "x" });
+        expect(out[1]).toEqual({});
+        expect(out[2]).toEqual({});
+    });
+    it("truncates extra entries to expected length", () => {
+        const out = parseScoreResponse('[{"score":1,"why":"a"},{"score":2,"why":"b"},{"score":3,"why":"c"}]', 2);
+        expect(out).toHaveLength(2);
+    });
+    it("returns empty objects on invalid input", () => {
+        const out = parseScoreResponse("not json at all", 2);
+        expect(out).toEqual([{}, {}]);
+    });
+});
+describe("clampScore", () => {
+    it("keeps scores already in [0, 10]", () => {
+        expect(clampScore(0)).toBe(0);
+        expect(clampScore(7.4)).toBe(7.4);
+        expect(clampScore(10)).toBe(10);
+    });
+    it("clamps out-of-range scores", () => {
+        expect(clampScore(-3)).toBe(0);
+        expect(clampScore(99)).toBe(10);
+    });
+    it("rounds to one decimal place", () => {
+        expect(clampScore(7.456)).toBe(7.5);
+        expect(clampScore(7.44)).toBe(7.4);
+    });
+    it("coerces string-numbers (LLMs sometimes wrap numbers in strings)", () => {
+        expect(clampScore("8")).toBe(8);
+        expect(clampScore("8.7")).toBe(8.7);
+    });
+    it("defaults non-finite values to 0", () => {
+        expect(clampScore(NaN)).toBe(0);
+        expect(clampScore(undefined)).toBe(0);
+        expect(clampScore(null)).toBe(0);
+        expect(clampScore("not a number")).toBe(0);
+    });
+});
+describe("clampWhy", () => {
+    it("passes short strings unchanged", () => {
+        expect(clampWhy("sharp eyes, well-lit")).toBe("sharp eyes, well-lit");
+    });
+    it("truncates at 80 chars (no ellipsis — caller's choice)", () => {
+        const long = "x".repeat(100);
+        expect(clampWhy(long)).toHaveLength(80);
+    });
+    it("collapses non-strings to empty", () => {
+        expect(clampWhy(42)).toBe("");
+        expect(clampWhy(undefined)).toBe("");
+        expect(clampWhy(null)).toBe("");
+        expect(clampWhy({ note: "x" })).toBe("");
+    });
+});
+//# sourceMappingURL=vision.test.js.map

package/dist/core/vision.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vision.test.js","sourceRoot":"","sources":["../../src/core/vision.test.ts"],"names":[],"mappings":"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"}

package/dist/core/whisper.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Whisper transcription backends. Tries local whisper.cpp first (free, fast,
+ * private), falls back to the OpenAI API if the binary isn't installed.
+ *
+ * Both backends normalize to the same shape:
+ *   { language, duration, segments: [{ start, end, text }] }
+ *
+ * Word-level timestamps are optional. When `wordTimestamps: true`:
+ *   - whisper.cpp uses `--max-len 1` to force one-word segments + `-ml 1`
+ *   - OpenAI verbose_json with `timestamp_granularities[]=word` returns words
+ * Both populate `words?: TranscriptWord[]` per segment when supported. When
+ * unsupported (older whisper.cpp build) the field is omitted; agents check.
+ */
+export interface TranscriptWord {
+    start: number;
+    end: number;
+    text: string;
+}
+export interface TranscriptSegment {
+    start: number;
+    end: number;
+    text: string;
+    /** Word-level timing if requested + available. */
+    words?: TranscriptWord[];
+    /**
+     * Speaker label, when present. Populated only when the transcript was
+     * produced by a tool that does diarization (whisperx, AssemblyAI, manual).
+     * gg-editor's bundled `transcribe` does not produce speaker labels.
+     */
+    speaker?: string;
+}
+export interface Transcript {
+    language: string;
+    durationSec: number;
+    segments: TranscriptSegment[];
+}
+/**
+ * OpenAI transcription model identifiers — see
+ * https://platform.openai.com/docs/api-reference/audio/createTranscription.
+ *
+ *   - `whisper-1`              Legacy Whisper V2. Only model with `verbose_json` +
+ *                              word/segment timestamp_granularities. Best when you
+ *                              need word-level timing (caption burn-in).
+ *   - `gpt-4o-transcribe`      GPT-4o speech model (~$0.006/min). Higher accuracy.
+ *                              JSON-only response — text + duration only, NO segments.
+ *   - `gpt-4o-mini-transcribe` Cheaper sibling (~$0.003/min). JSON-only.
+ *   - `gpt-4o-transcribe-diarize` Built-in speaker diarization. Returns segments with
+ *                              `speaker` labels via `diarized_json`. Replaces the
+ *                              whisperx + HF_TOKEN + pyannote chain. Requires
+ *                              `chunking_strategy: "auto"` for inputs > 30s.
+ */
+export type OpenAITranscriptionModel = "whisper-1" | "gpt-4o-transcribe" | "gpt-4o-mini-transcribe" | "gpt-4o-transcribe-diarize";
+export interface TranscribeOptions {
+    /** Force a backend; otherwise auto-pick (whisperx if diarize=true, else local first, then api). */
+    backend?: "local" | "api" | "whisperx";
+    /** Local whisper.cpp model file. Required if backend=local. */
+    modelPath?: string;
+    /** OpenAI API key (env OPENAI_API_KEY otherwise). */
+    apiKey?: string;
+    /**
+     * OpenAI model id. Default `whisper-1` because it's the only model that
+     * returns word/segment timestamps — required by burn_subtitles and the
+     * caption pipeline. Pick `gpt-4o-transcribe-diarize` for built-in speaker
+     * labels (no whisperx install needed).
+     */
+    apiModel?: OpenAITranscriptionModel;
+    /** ISO-639-1 language code; whisper auto-detects when omitted. */
+    language?: string;
+    /** Request word-level timestamps. Required for word-by-word burned captions. */
+    wordTimestamps?: boolean;
+    /**
+     * Run speaker diarization. Two paths exist:
+     *  1. Set `apiModel: "gpt-4o-transcribe-diarize"` — server-side diarization,
+     *     no extra dependencies. Recommended.
+     *  2. Set `backend: "whisperx"` (or omit and let auto-detect kick in) —
+     *     local whisperx + pyannote, requires `whisperx` on PATH and HF_TOKEN.
+     * The `diarize: true` flag alone routes to whisperx for backwards compat.
+     */
+    diarize?: boolean;
+    /** HF token override (otherwise reads HF_TOKEN env). Used by whisperx --hf_token. */
+    hfToken?: string;
+    /** whisperx model size. Default "base". */
+    whisperxModel?: string;
+    /**
+     * Server-side audio chunking for the OpenAI gpt-4o-transcribe family. Set to
+     * `"auto"` to have the server normalize loudness, run VAD, and chunk the file
+     * (up to 1500s for transcribe, 1400s for transcribe-diarize, both within the
+     * 25 MB upload cap). Required for `gpt-4o-transcribe-diarize` on inputs > 30s
+     * — auto-enabled in that case if you don't set it.
+     */
+    chunkingStrategy?: "auto";
+    /** Abort signal. */
+    signal?: AbortSignal;
+}
+export declare function detectLocalWhisper(): {
+    cmd: string;
+    argsPrefix: string[];
+} | undefined;
+/**
+ * Detect whisperx (the diarization-capable wrapper around whisper). It prints
+ * its name in --help; we accept either way it might be exposed.
+ */
+export declare function detectWhisperx(): boolean;
+export declare function detectApiKey(override?: string): string | undefined;
+export declare function transcribe(inputPath: string, opts?: TranscribeOptions): Promise<Transcript>;
+/**
+ * whisper.cpp with -ml=1 emits ONE entry per token. We regroup adjacent tokens
+ * back into sentence-ish segments (split at sentence punctuation) and attach
+ * the original tokens as the `words` array.
+ */
+export declare function regroupTokensIntoSegments(tokens: Array<{
+    offsets: {
+        from: number;
+        to: number;
+    };
+    text: string;
+}>): TranscriptSegment[];
+export interface WhisperxJson {
+    language?: string;
+    segments?: Array<{
+        start: number;
+        end: number;
+        text: string;
+        speaker?: string;
+        words?: Array<{
+            start: number;
+            end: number;
+            word: string;
+            speaker?: string;
+        }>;
+    }>;
+}
+/**
+ * Pure-data conversion: whisperx JSON shape → our Transcript shape.
+ * Exposed for unit tests; production code reads the file from disk first.
+ */
+export declare function whisperxJsonToTranscript(parsed: WhisperxJson, fallbackLanguage?: string): Transcript;
+/**
+ * Per-model request shape. The OpenAI transcription API rejects mismatched
+ * combinations (e.g. response_format=verbose_json on gpt-4o-transcribe), so we
+ * route per model. Pure function — exported for unit tests.
+ */
+export interface OpenAIRequestPlan {
+    /** What to put in the `response_format` form field. */
+    responseFormat: "verbose_json" | "json" | "diarized_json";
+    /** True if the model+request supports word-level + segment-level timing. */
+    emitsTimestamps: boolean;
+    /** True if the response will include speaker labels. */
+    emitsSpeakers: boolean;
+    /**
+     * Effective chunking_strategy to send (or undefined to omit). Auto-enables
+     * "auto" for diarize when the caller didn't explicitly set one.
+     */
+    chunkingStrategy: "auto" | undefined;
+}
+export declare function planOpenAIRequest(model: OpenAITranscriptionModel, opts: Pick<TranscribeOptions, "wordTimestamps" | "chunkingStrategy">): OpenAIRequestPlan;
+/**
+ * Response shape covering all three OpenAI variants we route. Optional fields
+ * are present on different models:
+ *   - whisper-1 verbose_json: text, language, duration, segments[], words[]
+ *   - gpt-4o-(mini-)transcribe json: text, language?, duration?
+ *   - gpt-4o-transcribe-diarize diarized_json: text, segments[{speaker,start,end,text}]
+ */
+interface OpenAITranscriptionResponse {
+    text?: string;
+    language?: string;
+    duration?: number;
+    segments?: Array<{
+        start: number;
+        end: number;
+        text: string;
+        /** Only on diarized_json. */
+        speaker?: string;
+    }>;
+    /** verbose_json + timestamp_granularities=word. */
+    words?: Array<{
+        start: number;
+        end: number;
+        word: string;
+    }>;
+}
+/**
+ * Pure-data conversion: OpenAI transcription response → our Transcript shape.
+ * Exported for unit tests; production code calls this after fetch.
+ */
+export declare function openAIResponseToTranscript(data: OpenAITranscriptionResponse, plan: OpenAIRequestPlan, opts: Pick<TranscribeOptions, "language" | "wordTimestamps">): Transcript;
+export {};
+//# sourceMappingURL=whisper.d.ts.map

package/dist/core/whisper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whisper.d.ts","sourceRoot":"","sources":["../../src/core/whisper.ts"],"names":[],"mappings":"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"}

package/dist/core/whisper.js

@@ -0,0 +1,380 @@
+import { spawn, spawnSync } from "node:child_process";
+import { createReadStream, mkdtempSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+// ── Backend detection ───────────────────────────────────────
+export function detectLocalWhisper() {
+    // whisper.cpp ships under several names depending on build:
+    //   - whisper-cli (modern)
+    //   - main (legacy whisper.cpp build artifact)
+    //   - whisper (some distros)
+    for (const cmd of ["whisper-cli", "whisper", "main"]) {
+        const r = spawnSync(cmd, ["--help"], { encoding: "utf8" });
+        if (r.status === 0 && (r.stdout + r.stderr).toLowerCase().includes("whisper")) {
+            return { cmd, argsPrefix: [] };
+        }
+    }
+    return undefined;
+}
+/**
+ * Detect whisperx (the diarization-capable wrapper around whisper). It prints
+ * its name in --help; we accept either way it might be exposed.
+ */
+export function detectWhisperx() {
+    const r = spawnSync("whisperx", ["--help"], { encoding: "utf8" });
+    return r.status === 0;
+}
+export function detectApiKey(override) {
+    return override ?? process.env.OPENAI_API_KEY;
+}
+// ── Public dispatcher ───────────────────────────────────────
+export async function transcribe(inputPath, opts = {}) {
+    const wantLocal = opts.backend === "local";
+    const wantApi = opts.backend === "api";
+    const wantWhisperx = opts.backend === "whisperx" || opts.diarize === true;
+    // Diarize via OpenAI (gpt-4o-transcribe-diarize) takes precedence over
+    // whisperx when explicitly requested by model id — no install needed.
+    const wantDiarizeApi = opts.apiModel === "gpt-4o-transcribe-diarize";
+    if (wantDiarizeApi) {
+        const apiKey = detectApiKey(opts.apiKey);
+        if (!apiKey) {
+            throw new Error("gpt-4o-transcribe-diarize requires OPENAI_API_KEY. Either set it, " +
+                "or set backend: 'whisperx' to diarize locally.");
+        }
+        return transcribeOpenAI(inputPath, apiKey, opts);
+    }
+    if (wantWhisperx) {
+        if (!detectWhisperx()) {
+            throw new Error("whisperx not on PATH. Install: pip install whisperx. " +
+                "Diarization also requires HF_TOKEN (free account at huggingface.co). " +
+                "Or set apiModel: 'gpt-4o-transcribe-diarize' for server-side diarization.");
+        }
+        return transcribeWhisperx(inputPath, opts);
+    }
+    if (!wantApi) {
+        const local = detectLocalWhisper();
+        if (local && opts.modelPath) {
+            return transcribeLocal(inputPath, local.cmd, opts);
+        }
+        if (wantLocal) {
+            throw new Error("whisper.cpp not found or modelPath not set. " +
+                "Install whisper.cpp and pass modelPath to ggml-*.bin.");
+        }
+    }
+    const apiKey = detectApiKey(opts.apiKey);
+    if (!apiKey) {
+        throw new Error("No transcription backend available. " +
+            "Either install whisper.cpp + pass modelPath, or set OPENAI_API_KEY.");
+    }
+    return transcribeOpenAI(inputPath, apiKey, opts);
+}
+// ── Local: whisper.cpp ──────────────────────────────────────
+function transcribeLocal(inputPath, cmd, opts) {
+    return new Promise((resolve, reject) => {
+        if (!opts.modelPath) {
+            reject(new Error("modelPath required for local whisper backend"));
+            return;
+        }
+        const args = [
+            "-m",
+            opts.modelPath,
+            "-f",
+            inputPath,
+            "-oj", // output JSON
+            "-of",
+            "/dev/stdout", // some builds ignore -of stdout; we re-derive from stderr if needed
+            "-pp", // print progress
+            "-nt", // no timestamps in printed text
+        ];
+        if (opts.language)
+            args.push("-l", opts.language);
+        if (opts.wordTimestamps) {
+            // whisper.cpp emits per-token timestamps in the JSON when -ml=1 forces
+            // single-token segments. We post-process to lift them onto words.
+            args.push("-ml", "1");
+        }
+        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        opts.signal?.addEventListener("abort", () => child.kill("SIGTERM"));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`whisper.cpp exited ${code}: ${stderr.slice(-500)}`));
+                return;
+            }
+            try {
+                // whisper.cpp -oj writes a JSON file alongside the input by default;
+                // when -of /dev/stdout is honoured, JSON is in stdout. Try both.
+                const json = stdout.trim().startsWith("{") ? stdout : (extractJsonBlock(stdout) ?? stderr);
+                const parsed = JSON.parse(json);
+                const tokens = parsed.transcription ?? [];
+                const segments = opts.wordTimestamps
+                    ? regroupTokensIntoSegments(tokens)
+                    : tokens.map((t) => ({
+                        start: t.offsets.from / 1000,
+                        end: t.offsets.to / 1000,
+                        text: t.text.trim(),
+                    }));
+                resolve({
+                    language: parsed.result?.language ?? opts.language ?? "unknown",
+                    durationSec: tokens[tokens.length - 1]?.offsets.to
+                        ? tokens[tokens.length - 1].offsets.to / 1000
+                        : 0,
+                    segments,
+                });
+            }
+            catch (e) {
+                reject(new Error(`failed to parse whisper.cpp JSON: ${e.message}`));
+            }
+        });
+    });
+}
+function extractJsonBlock(s) {
+    const open = s.indexOf("{");
+    const close = s.lastIndexOf("}");
+    if (open >= 0 && close > open)
+        return s.slice(open, close + 1);
+    return undefined;
+}
+/**
+ * whisper.cpp with -ml=1 emits ONE entry per token. We regroup adjacent tokens
+ * back into sentence-ish segments (split at sentence punctuation) and attach
+ * the original tokens as the `words` array.
+ */
+export function regroupTokensIntoSegments(tokens) {
+    if (tokens.length === 0)
+        return [];
+    const segments = [];
+    let current = [];
+    const flush = () => {
+        if (current.length === 0)
+            return;
+        segments.push({
+            start: current[0].start,
+            end: current[current.length - 1].end,
+            text: current
+                .map((w) => w.text)
+                .join(" ")
+                .replace(/\s+([.,!?;:])/g, "$1")
+                .trim(),
+            words: current,
+        });
+        current = [];
+    };
+    for (const t of tokens) {
+        const txt = t.text.trim();
+        if (!txt)
+            continue;
+        current.push({ start: t.offsets.from / 1000, end: t.offsets.to / 1000, text: txt });
+        if (/[.!?]$/.test(txt))
+            flush();
+    }
+    flush();
+    return segments;
+}
+/**
+ * Pure-data conversion: whisperx JSON shape → our Transcript shape.
+ * Exposed for unit tests; production code reads the file from disk first.
+ */
+export function whisperxJsonToTranscript(parsed, fallbackLanguage = "unknown") {
+    const segments = (parsed.segments ?? []).map((s) => ({
+        start: s.start,
+        end: s.end,
+        text: s.text.trim(),
+        ...(s.speaker ? { speaker: s.speaker } : {}),
+        ...(s.words && s.words.length > 0
+            ? {
+                words: s.words
+                    .filter((w) => Number.isFinite(w.start) && Number.isFinite(w.end))
+                    .map((w) => ({
+                    start: w.start,
+                    end: w.end,
+                    text: w.word.trim(),
+                })),
+            }
+            : {}),
+    }));
+    return {
+        language: parsed.language ?? fallbackLanguage,
+        durationSec: segments.at(-1)?.end ?? 0,
+        segments,
+    };
+}
+function transcribeWhisperx(inputPath, opts) {
+    return new Promise((resolve, reject) => {
+        const outDir = mkdtempSync(join(tmpdir(), "gg-editor-whisperx-"));
+        const args = [
+            inputPath,
+            "--model",
+            opts.whisperxModel ?? "base",
+            "--output_format",
+            "json",
+            "--output_dir",
+            outDir,
+        ];
+        if (opts.diarize)
+            args.push("--diarize");
+        if (opts.language)
+            args.push("--language", opts.language);
+        const hfToken = opts.hfToken ?? process.env.HF_TOKEN;
+        if (opts.diarize) {
+            if (!hfToken) {
+                reject(new Error("HF_TOKEN required for diarization. Get one free at huggingface.co/settings/tokens " +
+                    "and accept the pyannote/speaker-diarization-3.1 license."));
+                return;
+            }
+            args.push("--hf_token", hfToken);
+        }
+        const child = spawn("whisperx", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        opts.signal?.addEventListener("abort", () => child.kill("SIGTERM"));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`whisperx exited ${code}: ${stderr.slice(-500)}`));
+                return;
+            }
+            try {
+                // whisperx writes <basename>.json into outDir.
+                const files = readdirSync(outDir).filter((f) => f.endsWith(".json"));
+                if (files.length === 0) {
+                    reject(new Error("whisperx produced no JSON output"));
+                    return;
+                }
+                const parsed = JSON.parse(readFileSync(join(outDir, files[0]), "utf8"));
+                resolve(whisperxJsonToTranscript(parsed, opts.language ?? "unknown"));
+            }
+            catch (e) {
+                reject(new Error(`failed to parse whisperx JSON: ${e.message}`));
+            }
+        });
+    });
+}
+export function planOpenAIRequest(model, opts) {
+    switch (model) {
+        case "whisper-1":
+            // The only model that supports verbose_json + timestamp_granularities.
+            return {
+                responseFormat: "verbose_json",
+                emitsTimestamps: true,
+                emitsSpeakers: false,
+                chunkingStrategy: opts.chunkingStrategy,
+            };
+        case "gpt-4o-transcribe":
+        case "gpt-4o-mini-transcribe":
+            // GPT-4o transcribe family: JSON-only, no segments, no word timestamps.
+            // Higher accuracy than whisper-1 but you lose timing — picks like
+            // burn_subtitles still want whisper-1.
+            return {
+                responseFormat: "json",
+                emitsTimestamps: false,
+                emitsSpeakers: false,
+                chunkingStrategy: opts.chunkingStrategy,
+            };
+        case "gpt-4o-transcribe-diarize":
+            // diarized_json is required to receive speaker segments. Server requires
+            // chunking_strategy for inputs > 30s — we always send "auto" unless the
+            // caller explicitly set a different strategy.
+            return {
+                responseFormat: "diarized_json",
+                emitsTimestamps: true,
+                emitsSpeakers: true,
+                chunkingStrategy: opts.chunkingStrategy ?? "auto",
+            };
+    }
+}
+async function transcribeOpenAI(inputPath, apiKey, opts) {
+    const stat = statSync(inputPath);
+    if (stat.size > 25 * 1024 * 1024) {
+        throw new Error(`OpenAI transcription has a 25MB upload cap (got ${(stat.size / 1024 / 1024).toFixed(1)}MB). ` +
+            "Compress to mono 16kHz WAV via extract_audio (a 25-min interview fits comfortably). " +
+            "chunking_strategy splits long audio server-side but doesn't bypass the upload cap.");
+    }
+    const model = opts.apiModel ?? "whisper-1";
+    const plan = planOpenAIRequest(model, opts);
+    // Use native FormData/Blob — Node 20+ has them as globals. Cleaner than
+    // hand-rolling multipart, and the openai SDK does the same internally.
+    const fileBuf = await streamToBuffer(createReadStream(inputPath));
+    const form = new FormData();
+    form.append("model", model);
+    form.append("response_format", plan.responseFormat);
+    if (plan.responseFormat === "verbose_json" && opts.wordTimestamps) {
+        form.append("timestamp_granularities[]", "word");
+        form.append("timestamp_granularities[]", "segment");
+    }
+    if (plan.chunkingStrategy) {
+        form.append("chunking_strategy", plan.chunkingStrategy);
+    }
+    if (opts.language && model !== "gpt-4o-transcribe-diarize") {
+        // diarize model rejects language; the others accept it.
+        form.append("language", opts.language);
+    }
+    form.append("file", new Blob([new Uint8Array(fileBuf)], { type: "application/octet-stream" }), basename(inputPath));
+    const res = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: form,
+        signal: opts.signal,
+    });
+    if (!res.ok) {
+        const errText = await res.text().catch(() => "");
+        throw new Error(`OpenAI transcription HTTP ${res.status} (model=${model}): ${errText.slice(0, 300)}`);
+    }
+    const data = (await res.json());
+    return openAIResponseToTranscript(data, plan, opts);
+}
+/**
+ * Pure-data conversion: OpenAI transcription response → our Transcript shape.
+ * Exported for unit tests; production code calls this after fetch.
+ */
+export function openAIResponseToTranscript(data, plan, opts) {
+    // gpt-4o-(mini-)transcribe returns `text` only. Synthesise a single segment
+    // covering the whole clip so downstream tools (read_transcript, write_srt)
+    // still see *something* useful.
+    if (!plan.emitsTimestamps) {
+        const text = (data.text ?? "").trim();
+        return {
+            language: data.language ?? opts.language ?? "unknown",
+            durationSec: data.duration ?? 0,
+            segments: text ? [{ start: 0, end: data.duration ?? 0, text }] : [],
+        };
+    }
+    const segments = (data.segments ?? []).map((s) => ({
+        start: s.start,
+        end: s.end,
+        text: s.text.trim(),
+        ...(plan.emitsSpeakers && s.speaker ? { speaker: s.speaker } : {}),
+    }));
+    if (opts.wordTimestamps && data.words && segments.length > 0) {
+        // Distribute words into the segment whose [start,end] contains the word's
+        // midpoint. Linear walk; both arrays are already in order.
+        let segIdx = 0;
+        for (const w of data.words) {
+            const mid = (w.start + w.end) / 2;
+            while (segIdx < segments.length - 1 && mid > segments[segIdx].end)
+                segIdx += 1;
+            const seg = segments[segIdx];
+            if (!seg.words)
+                seg.words = [];
+            seg.words.push({ start: w.start, end: w.end, text: w.word });
+        }
+    }
+    return {
+        language: data.language ?? opts.language ?? "unknown",
+        durationSec: data.duration ?? segments.at(-1)?.end ?? 0,
+        segments,
+    };
+}
+function streamToBuffer(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on("data", (c) => chunks.push(c));
+        stream.on("end", () => resolve(Buffer.concat(chunks)));
+        stream.on("error", reject);
+    });
+}
+//# sourceMappingURL=whisper.js.map