@hed-hog/lms 0.0.361 → 0.0.365

package/dist/course/course-video-hls.service.js

@@ -0,0 +1,767 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var CourseVideoHlsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CourseVideoHlsService = exports.LMS_VIDEO_HLS_JOB = void 0;
+const api_prisma_1 = require("@hed-hog/api-prisma");
+const core_1 = require("@hed-hog/core");
+const queue_1 = require("@hed-hog/queue");
+const common_1 = require("@nestjs/common");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const util_1 = require("util");
+exports.LMS_VIDEO_HLS_JOB = 'lms.video.hls';
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const HLS_LADDER_PRESETS = {
+    480: { width: 854, height: 480, videoBitrate: '1500k', audioBitrate: '96k', bandwidth: 1500000 },
+    720: { width: 1280, height: 720, videoBitrate: '2800k', audioBitrate: '128k', bandwidth: 2800000 },
+    1080: { width: 1920, height: 1080, videoBitrate: '5000k', audioBitrate: '192k', bandwidth: 5000000 },
+};
+let CourseVideoHlsService = CourseVideoHlsService_1 = class CourseVideoHlsService {
+    constructor(prisma, fileService, settingService, notificationService, registry, queueJob) {
+        this.prisma = prisma;
+        this.fileService = fileService;
+        this.settingService = settingService;
+        this.notificationService = notificationService;
+        this.registry = registry;
+        this.queueJob = queueJob;
+        this.logger = new common_1.Logger(CourseVideoHlsService_1.name);
+    }
+    onModuleInit() {
+        this.registry.register(exports.LMS_VIDEO_HLS_JOB, this);
+        this.logger.log(`Registered handler for "${exports.LMS_VIDEO_HLS_JOB}"`);
+    }
+    async enqueueHls(params) {
+        var _a, _b, _c;
+        const lesson = await this.prisma.course_lesson.findFirst({
+            where: {
+                id: params.lessonId,
+                course_module_id: params.sessionId,
+                course_module: { course_id: params.courseId },
+            },
+            include: { course_module: true },
+        });
+        if (!lesson)
+            throw new common_1.NotFoundException('Lesson not found for this course session');
+        const content = this.parseContent(lesson.content);
+        if (lesson.type !== 'video' || (content === null || content === void 0 ? void 0 : content.sourceType) !== 'video') {
+            throw new common_1.BadRequestException('HLS processing is only available for video lessons');
+        }
+        if ((content === null || content === void 0 ? void 0 : content.videoProvedor) !== 'file_storage') {
+            throw new common_1.BadRequestException('HLS processing requires File Storage provider');
+        }
+        const original = await this.prisma.file.findUnique({
+            where: { id: params.originalFileId },
+            include: { file_mimetype: true },
+        });
+        if (!original)
+            throw new common_1.NotFoundException('Original video file not found');
+        const mimetype = (_b = (_a = original.file_mimetype) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '';
+        if (!this.isVideoFile(mimetype, original.filename)) {
+            throw new common_1.BadRequestException('Original file must be a video');
+        }
+        await this.upsertLessonFile({
+            lessonId: params.lessonId,
+            type: 'video_original',
+            fileId: params.originalFileId,
+            title: (_c = original.filename) !== null && _c !== void 0 ? _c : `Original video ${params.originalFileId}`,
+            public: false,
+            overwrite: true,
+        });
+        const asyncNotification = await this.notificationService.create({
+            user_id: params.userId,
+            title: 'Geração de HLS em andamento',
+            body: 'Preparando pipeline de processamento HLS do vídeo...',
+            type: 'progress',
+            progress: 1,
+            started_at: new Date().toISOString(),
+            auto_remove: false,
+            action_type: 'url',
+            action_url: '/queue/jobs',
+            action_data: {
+                source: 'lms-video-hls',
+                courseId: params.courseId,
+                lessonId: params.lessonId,
+            },
+        });
+        const job = await this.queueJob.enqueue({
+            type: exports.LMS_VIDEO_HLS_JOB,
+            queueName: exports.LMS_VIDEO_HLS_JOB,
+            payload: {
+                courseId: params.courseId,
+                sessionId: params.sessionId,
+                lessonId: params.lessonId,
+                originalFileId: params.originalFileId,
+                notificationId: asyncNotification.id,
+                notificationUserId: params.userId,
+            },
+            sourceModule: 'lms',
+            sourceEntity: 'course_lesson',
+            sourceEntityId: String(params.lessonId),
+            maxAttempts: 3,
+        });
+        await this.prisma.notification.update({
+            where: { id: asyncNotification.id },
+            data: {
+                action_data: {
+                    source: 'lms-video-hls',
+                    courseId: params.courseId,
+                    lessonId: params.lessonId,
+                    queueJobId: job.id,
+                },
+            },
+        });
+        await this.prisma.course_lesson.update({
+            where: { id: params.lessonId },
+            data: {
+                content: JSON.stringify(Object.assign(Object.assign({}, (content !== null && content !== void 0 ? content : {})), { sourceType: 'video', videoConversionJobId: job.id })),
+            },
+        });
+        return { queueJobId: job.id, status: 'queued' };
+    }
+    async handle(job) {
+        var _a, _b, _c, _d;
+        const { courseId, sessionId, lessonId, originalFileId } = job.payload;
+        const notificationContext = Number.isInteger(Number((_a = job.payload) === null || _a === void 0 ? void 0 : _a.notificationId)) &&
+            Number.isInteger(Number((_b = job.payload) === null || _b === void 0 ? void 0 : _b.notificationUserId))
+            ? { notificationId: Number(job.payload.notificationId), userId: Number(job.payload.notificationUserId) }
+            : undefined;
+        const emitProgress = async (message, metadata) => {
+            await this.createProgressEvent(job.id, message, metadata, notificationContext);
+        };
+        if (!courseId || !sessionId || !lessonId || !originalFileId) {
+            throw new Error('Invalid LMS HLS job payload');
+        }
+        this.logger.debug(`[HLS job=${job.id}] payload OK — courseId=${courseId} lessonId=${lessonId} originalFileId=${originalFileId} attempt=${job.attempts}/${job.max_attempts}`);
+        const maxInputBytes = this.getPositiveIntegerEnv('LMS_VIDEO_MAX_INPUT_BYTES');
+        const ffmpegTimeoutMs = (_c = this.getPositiveIntegerEnv('LMS_VIDEO_FFMPEG_TIMEOUT_MS')) !== null && _c !== void 0 ? _c : 1000 * 60 * 60 * 2;
+        this.logger.debug(`[HLS job=${job.id}] loading settings...`);
+        const settings = await this.settingService.getSettingValues([
+            'lms-hls-resolutions',
+            'lms-hls-segment-duration',
+            'lms-video-frame-capture-interval-seconds',
+            'lms-image-extraction-enabled',
+            'lms-audio-transcription-enabled',
+        ]);
+        this.logger.debug(`[HLS job=${job.id}] settings loaded — resolutions=${settings['lms-hls-resolutions']} segmentDuration=${settings['lms-hls-segment-duration']}`);
+        const hlsResolutions = this.parseResolutions(settings['lms-hls-resolutions']);
+        const segmentDuration = Math.max(2, Number(settings['lms-hls-segment-duration'] || 6));
+        const imageExtractionEnabled = settings['lms-image-extraction-enabled'] !== false;
+        const transcriptionEnabled = settings['lms-audio-transcription-enabled'] !== false;
+        const frameIntervalSeconds = this.resolveFrameIntervalSeconds(settings['lms-video-frame-capture-interval-seconds']);
+        this.logger.debug(`[HLS job=${job.id}] resolutions=${hlsResolutions.join(',')} segmentDuration=${segmentDuration}s imageExtraction=${imageExtractionEnabled} transcription=${transcriptionEnabled}`);
+        const workDir = await fs_1.promises.mkdtemp((0, path_1.join)((0, os_1.tmpdir)(), `lms-hls-${job.id}-`));
+        const inputPath = (0, path_1.join)(workDir, `original-${originalFileId}.mp4`);
+        const hlsOutDir = (0, path_1.join)(workDir, 'hls');
+        await fs_1.promises.mkdir(hlsOutDir, { recursive: true });
+        this.logger.debug(`[HLS job=${job.id}] workDir=${workDir}`);
+        const jobStartedAt = Date.now();
+        this.logger.log(`Queue job ${job.id}: starting HLS generation (lesson=${lessonId})`);
+        await emitProgress('Baixando vídeo original...', { phase: 'download_original', lessonId });
+        this.logger.debug(`[HLS job=${job.id}] downloading original file ${originalFileId} to ${inputPath}...`);
+        const downloaded = await this.fileService.downloadToPath(originalFileId, inputPath, maxInputBytes ? { maxBytes: maxInputBytes } : undefined);
+        const inputSizeMb = parseFloat((downloaded.size / (1024 * 1024)).toFixed(2));
+        this.logger.debug(`[HLS job=${job.id}] download complete — ${inputSizeMb} MB in ${Date.now() - jobStartedAt}ms`);
+        await emitProgress(`Vídeo baixado (${inputSizeMb} MB). Lendo dimensões e duração...`, {
+            phase: 'probe_duration',
+            lessonId,
+            inputSizeMb,
+        });
+        let probedDuration = null;
+        try {
+            this.logger.debug(`[HLS job=${job.id}] probing duration...`);
+            probedDuration = await this.probeDurationSeconds(inputPath, ffmpegTimeoutMs);
+            this.logger.debug(`[HLS job=${job.id}] duration=${probedDuration}s`);
+            if (probedDuration !== null && probedDuration > 0) {
+                await this.prisma.course_lesson.update({
+                    where: { id: lessonId },
+                    data: { duration_seconds: probedDuration },
+                });
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Queue job ${job.id}: failed to probe duration: ${(_d = err === null || err === void 0 ? void 0 : err.message) !== null && _d !== void 0 ? _d : err}`);
+        }
+        this.logger.debug(`[HLS job=${job.id}] probing source height...`);
+        const sourceHeight = await this.probeVideoHeight(inputPath);
+        this.logger.debug(`[HLS job=${job.id}] sourceHeight=${sourceHeight !== null && sourceHeight !== void 0 ? sourceHeight : 'unknown'}`);
+        const variants = this.buildHlsVariants(hlsResolutions, sourceHeight);
+        if (variants.length === 0) {
+            throw new Error(`No suitable HLS variants for source height ${sourceHeight !== null && sourceHeight !== void 0 ? sourceHeight : 'unknown'}`);
+        }
+        this.logger.log(`Queue job ${job.id}: building HLS with variants: ${variants.map((v) => v.height + 'p').join(', ')}`);
+        this.logger.debug(`[HLS job=${job.id}] ffmpeg encode starting — variants=${variants.map((v) => `${v.height}p@${v.videoBitrate}`).join(', ')} segmentDuration=${segmentDuration}s outDir=${hlsOutDir}`);
+        await emitProgress(`Gerando HLS (${variants.map((v) => v.height + 'p').join(', ')})...`, {
+            phase: 'hls_encode',
+            lessonId,
+            variants: variants.map((v) => v.height),
+        });
+        const encodeStart = Date.now();
+        await this.generateHls({ inputPath, outDir: hlsOutDir, variants, segmentDuration, timeoutMs: ffmpegTimeoutMs });
+        this.logger.debug(`[HLS job=${job.id}] ffmpeg encode complete in ${Date.now() - encodeStart}ms`);
+        // Count generated segments to log
+        let totalSegmentCount = 0;
+        for (const v of variants) {
+            const variantDir = (0, path_1.join)(hlsOutDir, `stream_${v.variantIndex}`);
+            const files = (await fs_1.promises.readdir(variantDir)).filter((f) => f.endsWith('.ts'));
+            this.logger.debug(`[HLS job=${job.id}] variant stream_${v.variantIndex} (${v.height}p): ${files.length} segments`);
+            totalSegmentCount += files.length;
+        }
+        this.logger.debug(`[HLS job=${job.id}] total segments to upload: ${totalSegmentCount} across ${variants.length} variants`);
+        await emitProgress('HLS gerado. Enviando arquivos para storage...', {
+            phase: 'hls_upload',
+            lessonId,
+        });
+        this.logger.debug(`[HLS job=${job.id}] starting upload of ${totalSegmentCount} segments + ${variants.length} playlists + 1 master`);
+        const uploadStart = Date.now();
+        const masterManifestFileId = await this.uploadHlsDirectory({
+            lessonId,
+            hlsOutDir,
+            variants,
+            emitProgress,
+        });
+        this.logger.debug(`[HLS job=${job.id}] upload complete in ${Date.now() - uploadStart}ms — masterFileId=${masterManifestFileId}`);
+        this.logger.debug(`[HLS job=${job.id}] upserting video_hls lesson file...`);
+        await this.upsertLessonFile({
+            lessonId,
+            type: 'video_hls',
+            fileId: masterManifestFileId,
+            title: 'HLS Stream',
+            public: false,
+            overwrite: true,
+        });
+        this.logger.log(`Queue job ${job.id}: HLS uploaded for lesson ${lessonId} (masterFileId=${masterManifestFileId})`);
+        let frameResults = [];
+        try {
+            if (imageExtractionEnabled) {
+                this.logger.debug(`[HLS job=${job.id}] starting frame extraction — interval=${frameIntervalSeconds}s`);
+                await emitProgress('Extraindo imagens do vídeo...', { phase: 'extract_frames', lessonId });
+                const frameStart = Date.now();
+                frameResults = await this.extractAndUploadLessonFrames({
+                    jobId: job.id,
+                    lessonId,
+                    inputPath,
+                    workDir,
+                    intervalSeconds: frameIntervalSeconds,
+                    timeoutMs: ffmpegTimeoutMs,
+                });
+                this.logger.debug(`[HLS job=${job.id}] frame extraction done — ${frameResults.length} frames in ${Date.now() - frameStart}ms`);
+                await emitProgress(frameResults.length > 0
+                    ? `Imagens extraídas com sucesso (${frameResults.length}).`
+                    : 'Nenhuma imagem foi extraída do vídeo.', { phase: 'extract_frames_done', lessonId, frames: frameResults.length });
+            }
+            else {
+                this.logger.debug(`[HLS job=${job.id}] frame extraction disabled — skipping`);
+            }
+            if (transcriptionEnabled) {
+                this.logger.debug(`[HLS job=${job.id}] starting audio extraction for transcription`);
+                await emitProgress('Extraindo áudio do vídeo...', { phase: 'extract_audio', lessonId });
+                const audioFileId = await this.extractAndUploadLessonAudio({
+                    courseId,
+                    lessonId,
+                    localInputPath: inputPath,
+                    tempDir: workDir,
+                });
+                if (audioFileId) {
+                    this.logger.debug(`[HLS job=${job.id}] audio extracted — fileId=${audioFileId}, enqueuing transcription`);
+                    await emitProgress('Áudio extraído. Agendando transcrição...', {
+                        phase: 'queue_transcription',
+                        lessonId,
+                        audioFileId,
+                    });
+                    const transcriptionJob = await this.queueJob.enqueue({
+                        type: 'lms.audio.transcribe',
+                        queueName: 'lms.audio.transcribe',
+                        payload: {
+                            courseId,
+                            sessionId,
+                            lessonId,
+                            audioFileId,
+                            parentJobId: job.id,
+                            notificationId: notificationContext === null || notificationContext === void 0 ? void 0 : notificationContext.notificationId,
+                            notificationUserId: notificationContext === null || notificationContext === void 0 ? void 0 : notificationContext.userId,
+                        },
+                        maxAttempts: 3,
+                    });
+                    await emitProgress(`Transcrição agendada no job #${transcriptionJob.id}.`, {
+                        phase: 'queue_transcription_done',
+                        lessonId,
+                        transcriptionJobId: transcriptionJob.id,
+                    });
+                    this.logger.debug(`[HLS job=${job.id}] transcription job enqueued — transcriptionJobId=${transcriptionJob.id}`);
+                    const totalMs = Date.now() - jobStartedAt;
+                    this.logger.log(`[HLS job=${job.id}] pipeline complete in ${totalMs}ms — lessonId=${lessonId} masterFileId=${masterManifestFileId} frames=${frameResults.length} transcriptionJob=${transcriptionJob.id}`);
+                    return {
+                        lessonId,
+                        probedDurationSeconds: probedDuration,
+                        masterManifestFileId,
+                        variants: variants.length,
+                        extractedFrames: frameResults.length,
+                        transcriptionJobId: transcriptionJob.id,
+                        totalMs,
+                    };
+                }
+                else {
+                    this.logger.debug(`[HLS job=${job.id}] audio extraction returned no file — skipping transcription`);
+                    await emitProgress('Áudio não disponível. Encerrando pipeline sem transcrição.', {
+                        phase: 'queue_transcription_skipped',
+                        lessonId,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error(`[HLS job=${job.id}] pipeline FAILED after ${Date.now() - jobStartedAt}ms — ${error instanceof Error ? error.stack : String(error)}`);
+            if (notificationContext) {
+                const message = error instanceof Error ? error.message : 'Falha no pipeline HLS.';
+                await this.updateAsyncNotification(notificationContext, 100, `Falha: ${message}`, false);
+            }
+            throw error;
+        }
+        finally {
+            this.logger.debug(`[HLS job=${job.id}] cleaning workDir ${workDir}`);
+            await fs_1.promises.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
+            this.logger.log(`Queue job ${job.id}: cleaned temporary folder ${workDir}`);
+        }
+        if (notificationContext) {
+            await this.updateAsyncNotification(notificationContext, 100, 'HLS gerado com sucesso.', true);
+        }
+        const totalMs = Date.now() - jobStartedAt;
+        this.logger.log(`[HLS job=${job.id}] pipeline complete in ${totalMs}ms — lessonId=${lessonId} masterFileId=${masterManifestFileId} frames=${frameResults.length} transcription=skipped`);
+        return {
+            lessonId,
+            probedDurationSeconds: probedDuration,
+            masterManifestFileId,
+            variants: variants.length,
+            extractedFrames: frameResults.length,
+            transcriptionJobId: null,
+            totalMs,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // HLS Generation
+    // ---------------------------------------------------------------------------
+    async generateHls(params) {
+        const { inputPath, outDir, variants, segmentDuration, timeoutMs } = params;
+        const ffmpegCmd = this.getFfmpegCommand();
+        // Create output directories for each variant
+        for (const v of variants) {
+            await fs_1.promises.mkdir((0, path_1.join)(outDir, `stream_${v.variantIndex}`), { recursive: true });
+        }
+        const args = ['-y', '-i', inputPath];
+        if (variants.length > 1) {
+            args.push('-filter_complex', `[0:v]split=${variants.length}${variants.map((v) => `[v${v.variantIndex}]`).join('')}`);
+            for (const v of variants) {
+                args.push(`-map`, `[v${v.variantIndex}]`, `-map`, `0:a:0`, `-c:v:${v.variantIndex}`, `libx264`, `-b:v:${v.variantIndex}`, v.videoBitrate, `-s:v:${v.variantIndex}`, `${v.width}x${v.height}`, `-c:a:${v.variantIndex}`, `aac`, `-b:a:${v.variantIndex}`, v.audioBitrate);
+            }
+            args.push('-var_stream_map', variants.map((v) => `v:${v.variantIndex},a:${v.variantIndex}`).join(' '));
+        }
+        else {
+            const v = variants[0];
+            args.push(`-c:v`, `libx264`, `-b:v`, v.videoBitrate, `-s`, `${v.width}x${v.height}`, `-c:a`, `aac`, `-b:a`, v.audioBitrate, `-var_stream_map`, `v:0,a:0`);
+        }
+        args.push(`-master_pl_name`, `master.m3u8`, `-f`, `hls`, `-hls_time`, String(segmentDuration), `-hls_list_size`, `0`, `-hls_segment_filename`, (0, path_1.join)(outDir, 'stream_%v', 'seg%03d.ts'), (0, path_1.join)(outDir, 'stream_%v', 'playlist.m3u8'));
+        try {
+            await execFileAsync(ffmpegCmd, args, {
+                maxBuffer: 1024 * 1024 * 20,
+                timeout: timeoutMs,
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.code) === 'ENOENT') {
+                throw new Error(`FFmpeg binary not found at "${ffmpegCmd}"`);
+            }
+            if ((error === null || error === void 0 ? void 0 : error.killed) && (error === null || error === void 0 ? void 0 : error.signal) === 'SIGTERM') {
+                throw new Error(`FFmpeg HLS generation timed out after ${timeoutMs}ms`);
+            }
+            throw error;
+        }
+    }
+    async uploadHlsDirectory(params) {
+        const { lessonId, hlsOutDir, variants, emitProgress } = params;
+        // Upload all segment files in batches
+        const BATCH_SIZE = 20;
+        const segmentUploads = [];
+        for (const v of variants) {
+            const variantDir = (0, path_1.join)(hlsOutDir, `stream_${v.variantIndex}`);
+            const files = await fs_1.promises.readdir(variantDir);
+            for (const filename of files) {
+                if (filename === 'playlist.m3u8')
+                    continue; // upload manifests separately
+                segmentUploads.push({
+                    localPath: (0, path_1.join)(variantDir, filename),
+                    location: `lms/lessons/hls/${lessonId}/stream_${v.variantIndex}`,
+                    filename,
+                });
+            }
+        }
+        const totalBatches = Math.ceil(segmentUploads.length / BATCH_SIZE);
+        this.logger.debug(`[HLS upload lessonId=${lessonId}] ${segmentUploads.length} segments → ${totalBatches} batches of ${BATCH_SIZE}`);
+        for (let i = 0; i < segmentUploads.length; i += BATCH_SIZE) {
+            const batch = segmentUploads.slice(i, i + BATCH_SIZE);
+            const batchIndex = Math.floor(i / BATCH_SIZE) + 1;
+            const batchStart = Date.now();
+            this.logger.debug(`[HLS upload lessonId=${lessonId}] batch ${batchIndex}/${totalBatches} — uploading ${batch.map((s) => s.filename).join(', ')}`);
+            await Promise.all(batch.map((seg) => this.fileService.uploadFromPath(seg.location, seg.localPath, {
+                originalname: seg.filename,
+                mimetype: 'video/MP2T',
+            })));
+            this.logger.debug(`[HLS upload lessonId=${lessonId}] batch ${batchIndex}/${totalBatches} done in ${Date.now() - batchStart}ms`);
+            await emitProgress(`Enviando segmentos HLS... (${batchIndex}/${totalBatches})`, { phase: 'hls_upload', lessonId, batchIndex, totalBatches });
+        }
+        // Upload variant playlists
+        for (const v of variants) {
+            const playlistPath = (0, path_1.join)(hlsOutDir, `stream_${v.variantIndex}`, 'playlist.m3u8');
+            this.logger.debug(`[HLS upload lessonId=${lessonId}] uploading playlist stream_${v.variantIndex}/playlist.m3u8`);
+            await this.fileService.uploadFromPath(`lms/lessons/hls/${lessonId}/stream_${v.variantIndex}`, playlistPath, { originalname: 'playlist.m3u8', mimetype: 'application/x-mpegURL' });
+            this.logger.debug(`[HLS upload lessonId=${lessonId}] playlist stream_${v.variantIndex} uploaded`);
+        }
+        // Upload master manifest last, keep its file ID
+        const masterPath = (0, path_1.join)(hlsOutDir, 'master.m3u8');
+        this.logger.debug(`[HLS upload lessonId=${lessonId}] uploading master.m3u8`);
+        const masterFile = await this.fileService.uploadFromPath(`lms/lessons/hls/${lessonId}`, masterPath, { originalname: 'master.m3u8', mimetype: 'application/x-mpegURL' });
+        this.logger.debug(`[HLS upload lessonId=${lessonId}] master.m3u8 uploaded — fileId=${masterFile.id}`);
+        return masterFile.id;
+    }
+    // ---------------------------------------------------------------------------
+    // Ladder helpers
+    // ---------------------------------------------------------------------------
+    parseResolutions(raw) {
+        const str = typeof raw === 'string' ? raw : '480,720,1080';
+        const parsed = str
+            .split(',')
+            .map((s) => parseInt(s.trim(), 10))
+            .filter((n) => !isNaN(n) && HLS_LADDER_PRESETS[n] !== undefined);
+        return parsed.length > 0 ? [...new Set(parsed)].sort((a, b) => a - b) : [480, 720, 1080];
+    }
+    buildHlsVariants(resolutions, sourceHeight) {
+        const effective = resolutions.filter((h) => sourceHeight === null || h <= sourceHeight);
+        // Always include at least the lowest quality or the source if it's below all configured resolutions
+        if (effective.length === 0 && sourceHeight !== null) {
+            const closest = resolutions.reduce((prev, curr) => Math.abs(curr - sourceHeight) < Math.abs(prev - sourceHeight) ? curr : prev);
+            effective.push(closest);
+        }
+        return effective.map((height, idx) => {
+            const preset = HLS_LADDER_PRESETS[height];
+            return Object.assign({ variantIndex: idx, height }, preset);
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // FFprobe helpers
+    // ---------------------------------------------------------------------------
+    async probeVideoHeight(inputPath) {
+        const ffprobeCmd = this.getFfprobeCommand();
+        try {
+            const { stdout } = await execFileAsync(ffprobeCmd, ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=height', '-of', 'default=noprint_wrappers=1:nokey=1', inputPath], { maxBuffer: 1024 * 1024, timeout: 30000, windowsHide: true });
+            const h = parseInt(stdout.trim(), 10);
+            return Number.isFinite(h) && h > 0 ? h : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    async probeDurationSeconds(inputPath, timeoutMs) {
+        const ffprobeCmd = this.getFfprobeCommand();
+        try {
+            const { stdout } = await execFileAsync(ffprobeCmd, ['-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', inputPath], { maxBuffer: 1024 * 1024, timeout: Math.min(timeoutMs, 30000), windowsHide: true });
+            const parsed = parseFloat(stdout.trim());
+            return Number.isFinite(parsed) && parsed > 0 ? Math.round(parsed) : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Frame extraction (same logic as CourseVideoConversionService)
+    // ---------------------------------------------------------------------------
+    async extractAndUploadLessonFrames(params) {
+        const intervalSeconds = Math.max(1, Math.floor(params.intervalSeconds));
+        const framesDir = (0, path_1.join)(params.workDir, 'frames');
+        await fs_1.promises.mkdir(framesDir, { recursive: true });
+        const pattern = (0, path_1.join)(framesDir, 'frame-%08d.jpg');
+        const ffmpegCmd = this.getFfmpegCommand();
+        try {
+            await execFileAsync(ffmpegCmd, ['-y', '-i', params.inputPath, '-vf', `fps=1/${intervalSeconds}`, '-q:v', '3', '-qmin', '2', '-qmax', '4', pattern], { maxBuffer: 1024 * 1024 * 20, timeout: params.timeoutMs, windowsHide: true });
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.code) === 'ENOENT')
+                throw new Error(`FFmpeg binary not found`);
+            throw error;
+        }
+        const frameFiles = (await fs_1.promises.readdir(framesDir))
+            .filter((n) => n.toLowerCase().endsWith('.jpg'))
+            .sort((a, b) => a.localeCompare(b));
+        if (frameFiles.length === 0) {
+            await this.prisma.course_lesson_video_frame.deleteMany({ where: { course_lesson_id: params.lessonId } });
+            return [];
+        }
+        const uploads = [];
+        for (let i = 0; i < frameFiles.length; i++) {
+            const fileName = frameFiles[i];
+            if (!fileName)
+                continue;
+            const framePath = (0, path_1.join)(framesDir, fileName);
+            const stats = await fs_1.promises.stat(framePath);
+            const uploaded = await this.fileService.uploadFromPath('lms/lessons/frames', framePath, {
+                originalname: fileName,
+                mimetype: 'image/jpeg',
+            });
+            uploads.push({ fileId: uploaded.id, timeSeconds: i * intervalSeconds, outputBytes: stats.size });
+        }
+        await this.prisma.course_lesson_video_frame.deleteMany({ where: { course_lesson_id: params.lessonId } });
+        await this.prisma.course_lesson_video_frame.createMany({
+            data: uploads.map((item) => ({
+                course_lesson_id: params.lessonId,
+                file_id: item.fileId,
+                time_seconds: item.timeSeconds,
+            })),
+        });
+        return uploads;
+    }
+    // ---------------------------------------------------------------------------
+    // Audio extraction (same logic as CourseVideoConversionService)
+    // ---------------------------------------------------------------------------
+    async extractAndUploadLessonAudio(params) {
+        var _a, _b;
+        const ffmpegCmd = this.getFfmpegCommand();
+        const mp3Path = (0, path_1.join)(params.tempDir, `lesson_${params.lessonId}_audio.mp3`);
+        try {
+            await execFileAsync(ffmpegCmd, ['-y', '-i', params.localInputPath, '-vn', '-ar', '16000', '-ac', '1', '-c:a', 'libmp3lame', '-b:a', '32k', mp3Path], { maxBuffer: 1024 * 1024 * 20, windowsHide: true });
+        }
+        catch (_c) {
+            return null;
+        }
+        try {
+            const course = await this.prisma.course.findUnique({
+                where: { id: params.courseId },
+                select: { locale_id: true },
+            });
+            const uploaded = await this.fileService.uploadFromPath('lms/lessons/audio', mp3Path, {
+                originalname: (0, path_1.basename)(mp3Path),
+                mimetype: 'audio/mp3',
+            });
+            const defaultLocale = await this.prisma.locale.findFirst({
+                where: { OR: [{ code: 'pt-BR' }, { code: 'pt' }] },
+                select: { id: true },
+                orderBy: { id: 'asc' },
+            });
+            const resolvedLocaleId = (_b = (_a = course === null || course === void 0 ? void 0 : course.locale_id) !== null && _a !== void 0 ? _a : defaultLocale === null || defaultLocale === void 0 ? void 0 : defaultLocale.id) !== null && _b !== void 0 ? _b : null;
+            const existing = await this.prisma.course_lesson_file.findFirst({
+                where: { course_lesson_id: params.lessonId, type: 'lesson_audio' },
+                select: { id: true },
+            });
+            if (existing) {
+                await this.prisma.course_lesson_file.update({
+                    where: { id: existing.id },
+                    data: { file_id: uploaded.id, locale_id: resolvedLocaleId, title: 'Audio Original.mp3', type: 'lesson_audio', is_public: false },
+                });
+            }
+            else {
+                await this.prisma.course_lesson_file.create({
+                    data: {
+                        course_lesson_id: params.lessonId,
+                        file_id: uploaded.id,
+                        title: 'Audio Original.mp3',
+                        type: 'lesson_audio',
+                        is_public: false,
+                        locale_id: resolvedLocaleId,
+                    },
+                });
+            }
+            return uploaded.id;
+        }
+        catch (_d) {
+            return null;
+        }
+        finally {
+            await fs_1.promises.rm(mp3Path, { force: true }).catch(() => undefined);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Shared helpers
+    // ---------------------------------------------------------------------------
+    async upsertLessonFile(params) {
+        if (params.overwrite) {
+            await this.prisma.course_lesson_file.deleteMany({
+                where: { course_lesson_id: params.lessonId, type: params.type },
+            });
+        }
+        return this.prisma.course_lesson_file.create({
+            data: {
+                course_lesson_id: params.lessonId,
+                file_id: params.fileId,
+                title: params.title,
+                type: params.type,
+                is_public: params.public,
+            },
+        });
+    }
+    async createProgressEvent(queueJobId, message, metadata, notificationContext) {
+        try {
+            await this.prisma.queue_job_event.create({
+                data: Object.assign({ queue_job_id: queueJobId, event_type: 'started', message }, (metadata ? { metadata } : {})),
+            });
+        }
+        catch (error) {
+            this.logger.warn(`Failed to persist progress event: ${error instanceof Error ? error.message : 'unknown'}`);
+        }
+        if (notificationContext) {
+            const progress = this.resolveNotificationProgress(metadata);
+            await this.updateAsyncNotification(notificationContext, progress, message);
+        }
+    }
+    resolveNotificationProgress(metadata) {
+        var _a;
+        const phase = String((_a = metadata === null || metadata === void 0 ? void 0 : metadata.phase) !== null && _a !== void 0 ? _a : '');
+        if (phase === 'download_original')
+            return 5;
+        if (phase === 'probe_duration')
+            return 12;
+        if (phase === 'hls_encode')
+            return 20;
+        if (phase === 'hls_upload')
+            return 65;
+        if (phase === 'extract_frames')
+            return 72;
+        if (phase === 'extract_frames_done')
+            return 78;
+        if (phase === 'extract_audio')
+            return 83;
+        if (phase === 'queue_transcription')
+            return 90;
+        if (phase === 'queue_transcription_done')
+            return 92;
+        if (phase === 'queue_transcription_skipped')
+            return 100;
+        return 15;
+    }
+    async updateAsyncNotification(context, progress, body, success) {
+        try {
+            await this.notificationService.updateProgress(context.userId, context.notificationId, Object.assign({ progress,
+                body }, (success != null ? { success } : {})));
+        }
+        catch (error) {
+            this.logger.warn(`Failed to update notification ${context.notificationId}: ${error instanceof Error ? error.message : 'unknown'}`);
+        }
+    }
+    parseContent(content) {
+        if (!content)
+            return null;
+        try {
+            return JSON.parse(content);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    isVideoFile(mimetype, filename) {
+        var _a, _b;
+        if (mimetype.startsWith('video/'))
+            return true;
+        const ext = (_b = (_a = (filename !== null && filename !== void 0 ? filename : '').split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
+        return ['mp4', 'm4v', 'mov', 'mkv', 'webm', 'avi', 'wmv', 'flv', 'ogv', 'm2ts', 'ts'].includes(ext);
+    }
+    resolveFrameIntervalSeconds(raw) {
+        const n = Number(raw);
+        return Number.isFinite(n) && n >= 1 ? Math.floor(n) : 10;
+    }
+    getPositiveIntegerEnv(name) {
+        const raw = process.env[name];
+        if (!raw)
+            return undefined;
+        const n = parseInt(raw, 10);
+        return Number.isFinite(n) && n > 0 ? n : undefined;
+    }
+    getFfmpegCommand() {
+        var _a;
+        const fromEnv = (_a = process.env.FFMPEG_PATH) === null || _a === void 0 ? void 0 : _a.trim();
+        if (fromEnv)
+            return fromEnv;
+        if (process.platform === 'win32') {
+            const found = this.findWindowsBinary('ffmpeg');
+            if (found)
+                return found;
+        }
+        return 'ffmpeg';
+    }
+    getFfprobeCommand() {
+        var _a, _b;
+        const fromEnv = (_a = process.env.FFPROBE_PATH) === null || _a === void 0 ? void 0 : _a.trim();
+        if (fromEnv)
+            return fromEnv;
+        const ffmpegEnv = (_b = process.env.FFMPEG_PATH) === null || _b === void 0 ? void 0 : _b.trim();
+        if (ffmpegEnv) {
+            const candidate = ffmpegEnv.replace(/ffmpeg(\.exe)?$/i, (_, ext) => `ffprobe${ext !== null && ext !== void 0 ? ext : ''}`);
+            if ((0, fs_1.existsSync)(candidate))
+                return candidate;
+        }
+        if (process.platform === 'win32') {
+            const found = this.findWindowsBinary('ffprobe');
+            if (found)
+                return found;
+        }
+        return 'ffprobe';
+    }
+    findWindowsBinary(name) {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (!localAppData)
+            return null;
+        const packagesRoot = (0, path_1.join)(localAppData, 'Microsoft', 'WinGet', 'Packages');
+        try {
+            const packageDirs = (0, fs_1.readdirSync)(packagesRoot, { withFileTypes: true })
+                .filter((e) => e.isDirectory() && e.name.startsWith('Gyan.FFmpeg'))
+                .map((e) => (0, path_1.join)(packagesRoot, e.name))
+                .sort((a, b) => b.localeCompare(a));
+            for (const dir of packageDirs) {
+                const direct = (0, path_1.join)(dir, 'bin', `${name}.exe`);
+                if ((0, fs_1.existsSync)(direct))
+                    return direct;
+                try {
+                    const versionDirs = (0, fs_1.readdirSync)(dir, { withFileTypes: true })
+                        .filter((e) => e.isDirectory() && e.name.toLowerCase().startsWith('ffmpeg-'))
+                        .map((e) => (0, path_1.join)(dir, e.name))
+                        .sort((a, b) => b.localeCompare(a));
+                    for (const vd of versionDirs) {
+                        const candidate = (0, path_1.join)(vd, 'bin', `${name}.exe`);
+                        if ((0, fs_1.existsSync)(candidate))
+                            return candidate;
+                    }
+                }
+                catch ( /* skip */_a) { /* skip */ }
+            }
+        }
+        catch ( /* skip */_b) { /* skip */ }
+        return null;
+    }
+};
+exports.CourseVideoHlsService = CourseVideoHlsService;
+exports.CourseVideoHlsService = CourseVideoHlsService = CourseVideoHlsService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => api_prisma_1.PrismaService))),
+    __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.FileService))),
+    __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.SettingService))),
+    __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.QueueJobService))),
+    __metadata("design:paramtypes", [api_prisma_1.PrismaService,
+        core_1.FileService,
+        core_1.SettingService,
+        core_1.NotificationService,
+        queue_1.QueueHandlerRegistry,
+        queue_1.QueueJobService])
+], CourseVideoHlsService);
+//# sourceMappingURL=course-video-hls.service.js.map