@hed-hog/lms 0.0.365 → 0.0.370

package/dist/course/course-audio-transcription.service.d.ts

@@ -2,6 +2,7 @@ import { PrismaService } from '@hed-hog/api-prisma';
 import { FileService, NotificationService, SettingService } from '@hed-hog/core';
 import { DatabaseQueueProvider, IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
 import { OnModuleInit } from '@nestjs/common';
+import { CourseAiUsageService } from './course-ai-usage.service';
 export declare class CourseAudioTranscriptionService implements OnModuleInit, IJobHandler {
     private readonly prismaService;
     private readonly settingService;
@@ -9,12 +10,75 @@ export declare class CourseAudioTranscriptionService implements OnModuleInit, IJ
     private readonly notificationService;
     private readonly registry;
     private readonly dbQueue;
+    private readonly aiUsageService;
     private readonly logger;
     private createProgressEvent;
     private resolveNotificationProgress;
     private updateAsyncNotification;
-    constructor(prismaService: PrismaService, settingService: SettingService, fileService: FileService, notificationService: NotificationService, registry: QueueHandlerRegistry, dbQueue: DatabaseQueueProvider);
+    constructor(prismaService: PrismaService, settingService: SettingService, fileService: FileService, notificationService: NotificationService, registry: QueueHandlerRegistry, dbQueue: DatabaseQueueProvider, aiUsageService: CourseAiUsageService);
     onModuleInit(): void;
+    private static readonly SUB_MAX_CHARS_PER_LINE;
+    private static readonly SUB_MAX_LINES;
+    private static readonly SUB_MAX_CPS;
+    private static readonly SUB_MAX_DURATION;
+    private static readonly SUB_MIN_DURATION;
+    private static readonly SUB_MIN_GAP;
+    private static readonly SUB_PAUSE_SPLIT;
+    private static readonly SUB_SOFT_BREAK_MIN_CHARS;
+    private static readonly SUB_SILENCE_NOISE_DB;
+    private static readonly SUB_SILENCE_MIN_DURATION;
+    /**
+     * Parses the configured reading speed (characters per second) from the
+     * `lms-subtitle-reading-speed` setting value, e.g. "...(15 cps)". Falls back
+     * to the Netflix adult default and clamps to a sane range.
+     */
+    private resolveReadingSpeedCps;
+    /**
+     * Resolves the silencedetect parameters from settings, falling back to the
+     * defaults and clamping to sane ranges (noise must be negative dB; duration a
+     * small positive number of seconds).
+     */
+    private resolveSilenceParams;
+    /**
+     * Detects silence intervals in the audio using FFmpeg's silencedetect filter.
+     * Subtitle starts are later snapped to the end of any silence they fall into,
+     * so captions appear when speech begins (not during intros/music or pauses).
+     * Returns an empty list on failure — silence alignment is best-effort.
+     */
+    private detectSilences;
+    /**
+     * Groups word-level timestamps into subtitle cues and adjusts their timing to
+     * the Netflix style guide. Text is stored on a single line; line breaking is a
+     * presentation concern handled at VTT generation (see subtitle.util.ts).
+     *
+     * `silences` (from detectSilences) is used to snap each cue's start to where
+     * speech actually begins, correcting Whisper's drift over intros/pauses.
+     */
+    private buildSubtitleSegments;
+    /**
+     * Merges single-word cues into a neighbour when they are not separated by a
+     * real pause — avoiding isolated words on screen. A lone word kept apart by a
+     * pause (≥ SUB_PAUSE_SPLIT) is preserved, since it is a genuine pause/emphasis.
+     * Merges only happen when the combined cue still fits two lines and the max
+     * duration, so size/legibility rules are never violated.
+     */
+    private mergeLoneWordCues;
+    /**
+     * Transcribes a single audio chunk with the given model and returns the raw
+     * OpenAI response body. whisper-1 uses verbose_json with word/segment
+     * timestamps; the gpt-4o-transcribe family only supports json (text only).
+     */
+    private transcribeChunk;
+    /**
+     * Converts a raw chunk transcription response into absolute-timed words,
+     * applying `offsetSeconds` (the chunk's position in the full audio):
+     *   - words[]    → real per-word timestamps (whisper-1)
+     *   - segments[] → synthesize even word timing within each segment (whisper-1
+     *                  verbose_json without word granularity)
+     *   - text only  → distribute words evenly across the chunk's speech window,
+     *                  skipping any leading silence detected by ffmpeg (gpt-4o)
+     */
+    private chunkResponseToWords;
     handle(job: {
         id: number;
         type: string;

package/dist/course/course-audio-transcription.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"course-audio-transcription.service.d.ts","sourceRoot":"","sources":["../../src/course/course-audio-transcription.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAgC,WAAW,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/G,OAAO,EAAE,qBAAqB,EAAE,WAAW,EAAqB,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EAIH,YAAY,EAEf,MAAM,gBAAgB,CAAC;AAexB,qBACa,+BAAgC,YAAW,YAAY,EAAE,WAAW;IAsE7E,OAAO,CAAC,QAAQ,CAAC,aAAa;IAE9B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAEpC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAEzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IA/E1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoD;YAE7D,mBAAmB;IAqBjC,OAAO,CAAC,2BAA2B;YAqBrB,uBAAuB;gBAyBlB,aAAa,EAAE,aAAa,EAE5B,cAAc,EAAE,cAAc,EAE9B,WAAW,EAAE,WAAW,EAExB,mBAAmB,EAAE,mBAAmB,EAExC,QAAQ,EAAE,oBAAoB,EAE9B,OAAO,EAAE,qBAAqB;IAGjD,YAAY;IAKN,MAAM,CAAC,GAAG,EAAE;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC7B,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAClC,GAAG,OAAO,CAAC,IAAI,CAAC;CA+TlB"}
+{"version":3,"file":"course-audio-transcription.service.d.ts","sourceRoot":"","sources":["../../src/course/course-audio-transcription.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAgC,WAAW,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/G,OAAO,EAAE,qBAAqB,EAAE,WAAW,EAAqB,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EAIH,YAAY,EAEf,MAAM,gBAAgB,CAAC;AAOxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAUjE,qBACa,+BAAgC,YAAW,YAAY,EAAE,WAAW;IAsE7E,OAAO,CAAC,QAAQ,CAAC,aAAa;IAE9B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAEpC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAEzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAjFjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoD;YAE7D,mBAAmB;IAqBjC,OAAO,CAAC,2BAA2B;YAqBrB,uBAAuB;gBAyBlB,aAAa,EAAE,aAAa,EAE5B,cAAc,EAAE,cAAc,EAE9B,WAAW,EAAE,WAAW,EAExB,mBAAmB,EAAE,mBAAmB,EAExC,QAAQ,EAAE,oBAAoB,EAE9B,OAAO,EAAE,qBAAqB,EAE9B,cAAc,EAAE,oBAAoB;IAGvD,YAAY;IAMZ,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAM;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAK;IAC1C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAM;IACzC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAK;IAC7C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IACjD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAS;IAC5C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAO;IAI9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAM;IAGtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAO;IACnD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAO;IAEvD;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAiB5B;;;;;OAKG;YACW,cAAc;IA8C5B;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAkH7B;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IA6BzB;;;;OAIG;YACW,eAAe;IAiD7B;;;;;;;;OAQG;IACH,OAAO,CAAC,oBAAoB;IAqEtB,MAAM,CAAC,GAAG,EAAE;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC7B,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAClC,GAAG,OAAO,CAAC,IAAI,CAAC;CA4VlB"}

package/dist/course/course-audio-transcription.service.js

@@ -27,6 +27,8 @@ const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const util_1 = require("util");
+const course_ai_usage_service_1 = require("./course-ai-usage.service");
+const subtitle_util_1 = require("./subtitle.util");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class CourseAudioTranscriptionService {
     async createProgressEvent(queueJobId, message, metadata) {
@@ -72,21 +74,323 @@ let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class
             this.logger.warn(`Failed to update async notification ${context.notificationId} for user ${context.userId}: ${error instanceof Error ? error.message : 'unknown error'}`);
         }
     }
-    constructor(prismaService, settingService, fileService, notificationService, registry, dbQueue) {
+    constructor(prismaService, settingService, fileService, notificationService, registry, dbQueue, aiUsageService) {
         this.prismaService = prismaService;
         this.settingService = settingService;
         this.fileService = fileService;
         this.notificationService = notificationService;
         this.registry = registry;
         this.dbQueue = dbQueue;
+        this.aiUsageService = aiUsageService;
         this.logger = new common_1.Logger(CourseAudioTranscriptionService_1.name);
     }
     onModuleInit() {
         this.registry.register('lms.audio.transcribe', this);
         this.logger.log('Registered handler for "lms.audio.transcribe"');
     }
-    async handle(job) {
+    /**
+     * Parses the configured reading speed (characters per second) from the
+     * `lms-subtitle-reading-speed` setting value, e.g. "...(15 cps)". Falls back
+     * to the Netflix adult default and clamps to a sane range.
+     */
+    resolveReadingSpeedCps(rawValue) {
+        const match = String(rawValue !== null && rawValue !== void 0 ? rawValue : '').match(/(\d+)\s*cps/i);
+        const cps = match ? Number(match[1]) : NaN;
+        if (!Number.isFinite(cps) || cps < 6 || cps > 25) {
+            return CourseAudioTranscriptionService_1.SUB_MAX_CPS;
+        }
+        return cps;
+    }
+    /**
+     * Resolves the silencedetect parameters from settings, falling back to the
+     * defaults and clamping to sane ranges (noise must be negative dB; duration a
+     * small positive number of seconds).
+     */
+    resolveSilenceParams(noiseRaw, durationRaw) {
+        const Svc = CourseAudioTranscriptionService_1;
+        let noiseDb = Number(noiseRaw);
+        // Noise must be a strictly negative dB value (0/empty/positive are invalid).
+        if (!noiseRaw || !Number.isFinite(noiseDb) || noiseDb >= 0 || noiseDb < -90) {
+            noiseDb = Svc.SUB_SILENCE_NOISE_DB;
+        }
+        let minDuration = Number(durationRaw);
+        if (!Number.isFinite(minDuration) || minDuration <= 0 || minDuration > 10) {
+            minDuration = Svc.SUB_SILENCE_MIN_DURATION;
+        }
+        return { noiseDb, minDuration };
+    }
+    /**
+     * Detects silence intervals in the audio using FFmpeg's silencedetect filter.
+     * Subtitle starts are later snapped to the end of any silence they fall into,
+     * so captions appear when speech begins (not during intros/music or pauses).
+     * Returns an empty list on failure — silence alignment is best-effort.
+     */
+    async detectSilences(audioPath, noiseDb = CourseAudioTranscriptionService_1.SUB_SILENCE_NOISE_DB, minDuration = CourseAudioTranscriptionService_1.SUB_SILENCE_MIN_DURATION) {
+        try {
+            const { stderr } = await execFileAsync('ffmpeg', [
+                '-i',
+                audioPath,
+                '-af',
+                `silencedetect=noise=${noiseDb}dB:d=${minDuration}`,
+                '-f',
+                'null',
+                '-',
+            ], { maxBuffer: 1024 * 1024 * 20, windowsHide: true });
+            const silences = [];
+            let curStart = null;
+            for (const line of String(stderr !== null && stderr !== void 0 ? stderr : '').split('\n')) {
+                const startMatch = line.match(/silence_start:\s*(-?[0-9.]+)/);
+                if (startMatch) {
+                    curStart = Math.max(0, parseFloat(startMatch[1]));
+                    continue;
+                }
+                const endMatch = line.match(/silence_end:\s*(-?[0-9.]+)/);
+                if (endMatch && curStart !== null) {
+                    const end = parseFloat(endMatch[1]);
+                    if (Number.isFinite(end) && end > curStart) {
+                        silences.push({ start: curStart, end });
+                    }
+                    curStart = null;
+                }
+            }
+            return silences;
+        }
+        catch (error) {
+            this.logger.warn(`silencedetect failed, skipping start alignment: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
+    /**
+     * Groups word-level timestamps into subtitle cues and adjusts their timing to
+     * the Netflix style guide. Text is stored on a single line; line breaking is a
+     * presentation concern handled at VTT generation (see subtitle.util.ts).
+     *
+     * `silences` (from detectSilences) is used to snap each cue's start to where
+     * speech actually begins, correcting Whisper's drift over intros/pauses.
+     */
+    buildSubtitleSegments(allWords, maxCps = CourseAudioTranscriptionService_1.SUB_MAX_CPS, silences = []) {
+        const Svc = CourseAudioTranscriptionService_1;
+        // Phase 1 — group words into cues respecting char count, duration and pauses.
+        const cues = [];
+        let buffer = [];
+        let bufferText = '';
+        const flush = () => {
+            if (buffer.length === 0)
+                return;
+            cues.push(buffer);
+            buffer = [];
+            bufferText = '';
+        };
+        for (const entry of allWords) {
+            const word = entry.word.trim();
+            if (!word)
+                continue;
+            const prev = buffer[buffer.length - 1];
+            const gapFromPrev = prev ? entry.start - prev.end : 0;
+            const tentativeText = bufferText ? `${bufferText} ${word}` : word;
+            const tentativeDuration = buffer.length > 0 ? entry.end - buffer[0].start : entry.end - entry.start;
+            if (buffer.length > 0 &&
+                (!(0, subtitle_util_1.fitsInTwoLines)(tentativeText, Svc.SUB_MAX_CHARS_PER_LINE) ||
+                    tentativeDuration > Svc.SUB_MAX_DURATION ||
+                    gapFromPrev >= Svc.SUB_PAUSE_SPLIT)) {
+                flush();
+            }
+            buffer.push(entry);
+            bufferText = bufferText ? `${bufferText} ${word}` : word;
+            // Break naturally at sentence-ending punctuation.
+            if (/[.!?…]$/.test(word)) {
+                flush();
+                continue;
+            }
+            // Soft break at clause punctuation once the cue is already substantial,
+            // so subtitles break at natural points (commas, pauses) instead of mid-clause.
+            if (/[,;:]$/.test(word) && bufferText.length >= Svc.SUB_SOFT_BREAK_MIN_CHARS) {
+                flush();
+            }
+        }
+        flush();
+        // Phase 1.5 — merge single-word cues that are not real pauses/emphasis.
+        const mergedCues = this.mergeLoneWordCues(cues);
+        // Phase 2 — build text and adjust display timing per cue.
+        const draft = mergedCues
+            .map((words) => ({
+            start: words[0].start,
+            endRaw: words[words.length - 1].end,
+            text: words.map((w) => w.word).join(' ').replace(/\s+/g, ' ').trim(),
+        }))
+            .filter((c) => c.text.length > 0);
+        const round = (n) => Math.max(0, Math.round(n * 1000) / 1000);
+        // Snap a start to the end of the silence it falls into (where speech begins).
+        // end_seconds is computed separately from `start`, so it will always be ≥ start.
+        const snapStart = (rawStart) => {
+            for (const s of silences) {
+                if (rawStart >= s.start && rawStart < s.end) {
+                    return s.end;
+                }
+            }
+            return rawStart;
+        };
+        const starts = draft.map((seg) => snapStart(seg.start));
+        return draft.map((seg, i) => {
+            const start = starts[i];
+            // Extend duration to satisfy minimum display time and reading speed (CPS),
+            // capped at the maximum duration.
+            let end = Math.max(seg.endRaw, start + Svc.SUB_MIN_DURATION, start + seg.text.length / maxCps);
+            end = Math.min(end, start + Svc.SUB_MAX_DURATION);
+            // Never overlap the next cue (keep a minimum gap from its aligned start).
+            const nextStart = starts[i + 1];
+            if (nextStart !== undefined) {
+                const maxEnd = nextStart - Svc.SUB_MIN_GAP;
+                if (maxEnd > start && end > maxEnd) {
+                    end = maxEnd;
+                }
+            }
+            if (end <= start) {
+                end = start + Svc.SUB_MIN_DURATION;
+            }
+            return {
+                start_seconds: round(start),
+                end_seconds: round(end),
+                text: seg.text,
+            };
+        });
+    }
+    /**
+     * Merges single-word cues into a neighbour when they are not separated by a
+     * real pause — avoiding isolated words on screen. A lone word kept apart by a
+     * pause (≥ SUB_PAUSE_SPLIT) is preserved, since it is a genuine pause/emphasis.
+     * Merges only happen when the combined cue still fits two lines and the max
+     * duration, so size/legibility rules are never violated.
+     */
+    mergeLoneWordCues(cues) {
+        const Svc = CourseAudioTranscriptionService_1;
+        const merged = [];
+        for (const cue of cues) {
+            const prev = merged[merged.length - 1];
+            if (prev && (prev.length === 1 || cue.length === 1)) {
+                const gap = cue[0].start - prev[prev.length - 1].end;
+                const combined = [...prev, ...cue];
+                const combinedText = combined.map((w) => w.word).join(' ');
+                const combinedDuration = cue[cue.length - 1].end - prev[0].start;
+                if (gap < Svc.SUB_PAUSE_SPLIT &&
+                    combinedDuration <= Svc.SUB_MAX_DURATION &&
+                    (0, subtitle_util_1.fitsInTwoLines)(combinedText, Svc.SUB_MAX_CHARS_PER_LINE)) {
+                    merged[merged.length - 1] = combined;
+                    continue;
+                }
+            }
+            merged.push(cue);
+        }
+        return merged;
+    }
+    /**
+     * Transcribes a single audio chunk with the given model and returns the raw
+     * OpenAI response body. whisper-1 uses verbose_json with word/segment
+     * timestamps; the gpt-4o-transcribe family only supports json (text only).
+     */
+    async transcribeChunk(chunkBuffer, chunkName, model, apiKey, language) {
+        var _a, _b, _c, _d, _e;
+        const formData = new FormData();
+        formData.append('file', new Blob([new Uint8Array(chunkBuffer)], { type: 'audio/mpeg' }), chunkName);
+        const isWhisper = model === 'whisper-1';
+        formData.append('model', model);
+        // Only whisper-1 supports verbose_json + timestamp_granularities; the
+        // gpt-4o-transcribe family returns 400 for anything other than json/text.
+        formData.append('response_format', isWhisper ? 'verbose_json' : 'json');
+        formData.append('language', language);
+        if (isWhisper) {
+            formData.append('timestamp_granularities[]', 'word');
+            formData.append('timestamp_granularities[]', 'segment');
+        }
+        const headers = {
+            Authorization: `Bearer ${apiKey}`,
+        };
+        const maybeHeaders = (_b = (_a = formData).getHeaders) === null || _b === void 0 ? void 0 : _b.call(_a);
+        if (maybeHeaders && typeof maybeHeaders === 'object') {
+            Object.assign(headers, maybeHeaders);
+        }
+        try {
+            const response = await axios_1.default.post('https://api.openai.com/v1/audio/transcriptions', formData, { headers });
+            return response.data;
+        }
+        catch (axiosErr) {
+            const status = (_c = axiosErr === null || axiosErr === void 0 ? void 0 : axiosErr.response) === null || _c === void 0 ? void 0 : _c.status;
+            const body = JSON.stringify((_e = (_d = axiosErr === null || axiosErr === void 0 ? void 0 : axiosErr.response) === null || _d === void 0 ? void 0 : _d.data) !== null && _e !== void 0 ? _e : {});
+            this.logger.error(`OpenAI transcription request failed — model=${model} language=${language} status=${status} body=${body}`);
+            throw axiosErr;
+        }
+    }
+    /**
+     * Converts a raw chunk transcription response into absolute-timed words,
+     * applying `offsetSeconds` (the chunk's position in the full audio):
+     *   - words[]    → real per-word timestamps (whisper-1)
+     *   - segments[] → synthesize even word timing within each segment (whisper-1
+     *                  verbose_json without word granularity)
+     *   - text only  → distribute words evenly across the chunk's speech window,
+     *                  skipping any leading silence detected by ffmpeg (gpt-4o)
+     */
+    chunkResponseToWords(data, offsetSeconds, silences) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const out = [];
+        const wordEntries = (_a = data === null || data === void 0 ? void 0 : data.words) !== null && _a !== void 0 ? _a : [];
+        if (wordEntries.length > 0) {
+            for (const w of wordEntries) {
+                const wordText = String((_b = w === null || w === void 0 ? void 0 : w.word) !== null && _b !== void 0 ? _b : '').trim();
+                if (!wordText)
+                    continue;
+                out.push({
+                    word: wordText,
+                    start: offsetSeconds + Number((_c = w === null || w === void 0 ? void 0 : w.start) !== null && _c !== void 0 ? _c : 0),
+                    end: offsetSeconds + Number((_d = w === null || w === void 0 ? void 0 : w.end) !== null && _d !== void 0 ? _d : 0),
+                });
+            }
+            return out;
+        }
+        const segments = (_e = data === null || data === void 0 ? void 0 : data.segments) !== null && _e !== void 0 ? _e : [];
+        if (segments.length > 0) {
+            // whisper-1 verbose_json fallback: synthesize from segments
+            for (const segment of segments) {
+                const text = String((_f = segment === null || segment === void 0 ? void 0 : segment.text) !== null && _f !== void 0 ? _f : '').trim();
+                if (!text)
+                    continue;
+                const start = offsetSeconds + Number((_g = segment === null || segment === void 0 ? void 0 : segment.start) !== null && _g !== void 0 ? _g : 0);
+                const end = offsetSeconds + Number((_h = segment === null || segment === void 0 ? void 0 : segment.end) !== null && _h !== void 0 ? _h : 0);
+                const words = text.split(/\s+/).filter(Boolean);
+                const dur = Math.max(0, end - start);
+                const wordDur = words.length > 0 ? dur / words.length : 0;
+                for (let wi = 0; wi < words.length; wi++) {
+                    out.push({
+                        word: words[wi],
+                        start: start + wi * wordDur,
+                        end: start + (wi + 1) * wordDur,
+                    });
+                }
+            }
+            return out;
+        }
+        // json-only models (gpt-4o-transcribe etc): distribute over the speech
+        // window of the chunk, skipping any leading silence detected by ffmpeg.
+        const fullText = String((_j = data === null || data === void 0 ? void 0 : data.text) !== null && _j !== void 0 ? _j : '').trim();
+        const words = fullText.split(/\s+/).filter(Boolean);
+        const chunkDur = 60;
+        const chunkSpeechOffset = silences
+            .filter((s) => s.start <= offsetSeconds + 1 &&
+            s.end > offsetSeconds &&
+            s.end <= offsetSeconds + chunkDur)
+            .reduce((max, s) => Math.max(max, s.end - offsetSeconds), 0);
+        const speechDur = Math.max(1, chunkDur - chunkSpeechOffset);
+        const wordDur = words.length > 0 ? speechDur / words.length : 0;
+        for (let wi = 0; wi < words.length; wi++) {
+            out.push({
+                word: words[wi],
+                start: offsetSeconds + chunkSpeechOffset + wi * wordDur,
+                end: offsetSeconds + chunkSpeechOffset + (wi + 1) * wordDur,
+            });
+        }
+        return out;
+    }
+    async handle(job) {
+        var _a, _b, _c, _d, _e;
         const { courseId, lessonId, audioFileId, parentJobId, notificationId, notificationUserId } = job.payload;
         const notificationContext = Number.isInteger(Number(notificationId)) &&
             Number.isInteger(Number(notificationUserId))
@@ -107,8 +411,19 @@ let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class
         const settings = await this.settingService.getSettingValues([
             'ai-openai-profile-id',
             'lms-audio-transcription-enabled',
+            'lms-subtitle-reading-speed',
+            'lms-subtitle-silence-noise-db',
+            'lms-subtitle-silence-min-duration',
+            'lms-transcription-model',
         ]);
         const transcriptionEnabled = settings['lms-audio-transcription-enabled'] !== false;
+        const transcriptionModel = String((_a = settings['lms-transcription-model']) !== null && _a !== void 0 ? _a : 'whisper-1');
+        // The model choice drives the mode: whisper-1 returns real timestamps, so it
+        // runs in a single pass. The gpt-4o models return no timestamps, so they run
+        // hybrid — whisper-1 supplies the timing and is merged onto the gpt-4o text.
+        const useHybrid = transcriptionModel !== 'whisper-1';
+        const readingSpeedCps = this.resolveReadingSpeedCps(settings['lms-subtitle-reading-speed']);
+        const silenceParams = this.resolveSilenceParams(settings['lms-subtitle-silence-noise-db'], settings['lms-subtitle-silence-min-duration']);
         if (!transcriptionEnabled) {
             const msg = `Transcrição desabilitada nas configurações do LMS (lms-audio-transcription-enabled=false).`;
             if (notificationContext) {
@@ -141,7 +456,8 @@ let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class
             where: { id: courseId },
             include: { locale: true },
         });
-        const language = (_b = (_a = course === null || course === void 0 ? void 0 : course.locale) === null || _a === void 0 ? void 0 : _a.code) !== null && _b !== void 0 ? _b : 'pt';
+        const language = ((_c = (_b = course === null || course === void 0 ? void 0 : course.locale) === null || _b === void 0 ? void 0 : _b.code) !== null && _c !== void 0 ? _c : 'pt').split('-')[0];
+        const localeId = (_d = course === null || course === void 0 ? void 0 : course.locale_id) !== null && _d !== void 0 ? _d : null;
         const tempDir = (0, path_1.join)((0, os_1.tmpdir)(), `lms-transcribe-${lessonId}-${Date.now()}`);
         await fs_1.promises.mkdir(tempDir, { recursive: true });
         try {
@@ -209,7 +525,10 @@ let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class
                 lessonId,
                 chunks: chunks.length,
             });
-            const allSegments = [];
+            // Detect silence in the full normalized audio so subtitle starts can be
+            // aligned to where speech actually begins (intros, music, long pauses).
+            const silences = await this.detectSilences(normalizedAudioPath, silenceParams.noiseDb, silenceParams.minDuration);
+            const allWords = [];
             for (let i = 0; i < chunks.length; i += 1) {
                 const chunkName = chunks[i];
                 if (!chunkName)
@@ -223,32 +542,29 @@ let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class
                 const chunkPath = (0, path_1.join)(tempDir, chunkName);
                 const offsetSeconds = i * 60;
                 const chunkBuffer = await fs_1.promises.readFile(chunkPath);
-                const formData = new FormData();
-                formData.append('file', new Blob([chunkBuffer], { type: 'audio/mpeg' }), chunkName);
-                formData.append('model', 'whisper-1');
-                formData.append('response_format', 'verbose_json');
-                formData.append('language', language);
-                const headers = {
-                    Authorization: `Bearer ${apiKey}`,
-                };
-                const maybeHeaders = (_d = (_c = formData).getHeaders) === null || _d === void 0 ? void 0 : _d.call(_c);
-                if (maybeHeaders && typeof maybeHeaders === 'object') {
-                    Object.assign(headers, maybeHeaders);
+                if (useHybrid) {
+                    // Hybrid: real timing from whisper-1 + premium text from the chosen
+                    // model, merged by word alignment (see alignTextToTimings).
+                    const [timingData, textData] = await Promise.all([
+                        this.transcribeChunk(chunkBuffer, chunkName, 'whisper-1', apiKey, language),
+                        this.transcribeChunk(chunkBuffer, chunkName, transcriptionModel, apiKey, language),
+                    ]);
+                    const timedWords = this.chunkResponseToWords(timingData, offsetSeconds, silences);
+                    const cleanText = String((_e = textData === null || textData === void 0 ? void 0 : textData.text) !== null && _e !== void 0 ? _e : '').trim();
+                    allWords.push(...(0, subtitle_util_1.alignTextToTimings)(timedWords, cleanText));
                 }
-                const response = await axios_1.default.post('https://api.openai.com/v1/audio/transcriptions', formData, { headers });
-                const segments = (_f = (_e = response.data) === null || _e === void 0 ? void 0 : _e.segments) !== null && _f !== void 0 ? _f : [];
-                for (const segment of segments) {
-                    const text = String((_g = segment === null || segment === void 0 ? void 0 : segment.text) !== null && _g !== void 0 ? _g : '').trim();
-                    if (!text)
-                        continue;
-                    allSegments.push({
-                        course_lesson_id: lessonId,
-                        start_seconds: offsetSeconds + Number((_h = segment === null || segment === void 0 ? void 0 : segment.start) !== null && _h !== void 0 ? _h : 0),
-                        end_seconds: offsetSeconds + Number((_j = segment === null || segment === void 0 ? void 0 : segment.end) !== null && _j !== void 0 ? _j : 0),
-                        text,
-                    });
+                else {
+                    const data = await this.transcribeChunk(chunkBuffer, chunkName, transcriptionModel, apiKey, language);
+                    allWords.push(...this.chunkResponseToWords(data, offsetSeconds, silences));
                 }
             }
+            const allSegments = this.buildSubtitleSegments(allWords, readingSpeedCps, silences).map((seg) => ({
+                course_lesson_id: lessonId,
+                locale_id: localeId,
+                start_seconds: seg.start_seconds,
+                end_seconds: seg.end_seconds,
+                text: seg.text,
+            }));
             await emitProgress('Salvando transcrição gerada pela IA...', {
                 phase: 'transcription_save',
                 lessonId,
@@ -256,13 +572,31 @@ let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class
             });
             await this.prismaService.$transaction([
                 this.prismaService.course_lesson_transcription_segment.deleteMany({
-                    where: { course_lesson_id: lessonId },
+                    where: { course_lesson_id: lessonId, locale_id: localeId },
                 }),
                 this.prismaService.course_lesson_transcription_segment.createMany({
                     data: allSegments,
                 }),
             ]);
             this.logger.log(`Transcription saved for lesson ${lessonId}: ${allSegments.length} segments`);
+            // Record AI cost (transcription is billed per second of audio). Hybrid
+            // mode runs two passes (whisper-1 for timing + the chosen model for text),
+            // so both are charged.
+            const audioSeconds = allWords.length > 0 ? allWords[allWords.length - 1].end : 0;
+            await this.aiUsageService.recordTranscriptionUsage({
+                courseId,
+                lessonId,
+                model: transcriptionModel,
+                audioSeconds,
+            });
+            if (useHybrid) {
+                await this.aiUsageService.recordTranscriptionUsage({
+                    courseId,
+                    lessonId,
+                    model: 'whisper-1',
+                    audioSeconds,
+                });
+            }
             // Automatically trigger XP calculation after transcription completes.
             try {
                 const existingMap = await this.prismaService.lesson_xp_map.findUnique({
@@ -322,6 +656,22 @@ let CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = class
     }
 };
 exports.CourseAudioTranscriptionService = CourseAudioTranscriptionService;
+// Subtitle rules — Netflix Timed Text Style Guide (pt-BR).
+CourseAudioTranscriptionService.SUB_MAX_CHARS_PER_LINE = 42;
+CourseAudioTranscriptionService.SUB_MAX_LINES = 2;
+CourseAudioTranscriptionService.SUB_MAX_CPS = 17; // reading speed (chars per second)
+CourseAudioTranscriptionService.SUB_MAX_DURATION = 7; // seconds
+CourseAudioTranscriptionService.SUB_MIN_DURATION = 5 / 6; // ~0.833s
+CourseAudioTranscriptionService.SUB_MIN_GAP = 0.084; // ~2 frames @ 24fps
+CourseAudioTranscriptionService.SUB_PAUSE_SPLIT = 0.7; // silence that forces a new cue
+// Soft break at commas/semicolons/colons only once the cue already holds a
+// readable chunk (~one line), so we break at natural points without
+// producing tiny fragments.
+CourseAudioTranscriptionService.SUB_SOFT_BREAK_MIN_CHARS = 38;
+// Silence detection used to snap subtitle starts to where speech actually
+// begins (Whisper word timestamps drift over intros/music and long pauses).
+CourseAudioTranscriptionService.SUB_SILENCE_NOISE_DB = -30; // silencedetect threshold
+CourseAudioTranscriptionService.SUB_SILENCE_MIN_DURATION = 0.3; // min silence length (s)
 exports.CourseAudioTranscriptionService = CourseAudioTranscriptionService = CourseAudioTranscriptionService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => api_prisma_1.PrismaService))),
@@ -330,11 +680,13 @@ exports.CourseAudioTranscriptionService = CourseAudioTranscriptionService = Cour
     __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.NotificationService))),
     __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.QueueHandlerRegistry))),
     __param(5, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.DatabaseQueueProvider))),
+    __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => course_ai_usage_service_1.CourseAiUsageService))),
     __metadata("design:paramtypes", [api_prisma_1.PrismaService,
         core_1.SettingService,
         core_1.FileService,
         core_1.NotificationService,
         queue_1.QueueHandlerRegistry,
-        queue_1.DatabaseQueueProvider])
+        queue_1.DatabaseQueueProvider,
+        course_ai_usage_service_1.CourseAiUsageService])
 ], CourseAudioTranscriptionService);
 //# sourceMappingURL=course-audio-transcription.service.js.map