@hed-hog/lms 0.0.364 → 0.0.366

package/src/course/course.controller.ts

@@ -5,23 +5,26 @@ import {
     Controller,
     Delete,
     Get,
-    HttpCode,
-    HttpStatus,
     Param,
     ParseIntPipe,
     Patch,
     Post,
     Query,
 } from '@nestjs/common';
+import { CourseExportService } from './course-export.service';
 import { CourseService } from './course.service';
-import { CreateCourseDto } from './dto/create-course.dto';
 import { CleanupCourseStorageDto } from './dto/cleanup-course-storage.dto';
+import { CreateCourseDto } from './dto/create-course.dto';
+import { CreateCourseExportDto } from './dto/create-course-export.dto';
 import { UpdateCourseDto } from './dto/update-course.dto';
 
 @Role()
 @Controller('lms/courses')
 export class CourseController {
-  constructor(private readonly courseService: CourseService) {}
+  constructor(
+    private readonly courseService: CourseService,
+    private readonly courseExportService: CourseExportService,
+  ) {}
 
   @Get()
   list(
@@ -83,6 +86,32 @@ export class CourseController {
     );
   }
 
+  @Get(':id/exports')
+  listExports(@Param('id', ParseIntPipe) id: number) {
+    return this.courseExportService.listExports(id);
+  }
+
+  @Post(':id/exports')
+  createExport(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: CreateCourseExportDto,
+    @User() user: any,
+  ) {
+    return this.courseExportService.enqueueScorm12Export(
+      id,
+      Number(user?.id || 0),
+      dto,
+    );
+  }
+
+  @Delete(':id/exports/:exportId')
+  deleteExport(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('exportId', ParseIntPipe) exportId: number,
+  ) {
+    return this.courseExportService.deleteExport(id, exportId);
+  }
+
   @Get(':id')
   getById(@Param('id', ParseIntPipe) id: number) {
     return this.courseService.getById(id);
@@ -106,19 +135,4 @@ export class CourseController {
     return this.courseService.remove(id, Number(user?.id || 0) || null);
   }
 
-  @Get(':courseId/video-resolution-profiles')
-  getCourseVideoProfiles(
-    @Param('courseId', ParseIntPipe) courseId: number,
-  ) {
-    return this.courseService.getCourseVideoProfiles(courseId);
-  }
-
-  @Post(':courseId/video-resolution-profiles/sync')
-  @HttpCode(HttpStatus.OK)
-  syncCourseVideoProfiles(
-    @Param('courseId', ParseIntPipe) courseId: number,
-    @Body() body: { profileIds: number[] },
-  ) {
-    return this.courseService.syncCourseVideoProfiles(courseId, body.profileIds ?? []);
-  }
 }

package/src/course/course.mcp-tools.ts

@@ -244,7 +244,7 @@ export class LmsCoursesMcpTools {
         courseId: { type: 'number', description: 'Course ID' },
         sessionId: { type: 'number', description: 'Session ID' },
         titulo: { type: 'string', description: 'Lesson title (required, max 255)' },
-        tipo: { type: 'string', description: 'Lesson type (required): video|questao|post|exercicio' },
+        tipo: { type: 'string', description: 'Lesson type (required): video|questao|post' },
         descricaoPublica: { type: 'string', description: 'Public description' },
         descricaoPrivada: { type: 'string', description: 'Private description' },
         duracao: { type: 'number', description: 'Duration in seconds' },

package/src/course/course.module.ts

@@ -1,3 +1,4 @@
+import { AgentModule } from '@hed-hog/agent';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { CoreModule } from '@hed-hog/core';
 import { QueueModule } from '@hed-hog/queue';
@@ -8,11 +9,17 @@ import { CourseOperationsIntegrationService } from './course-operations-integrat
 import { CourseOperationsController } from './course-operations.controller';
 import { CourseStructureController } from './course-structure.controller';
 import { CourseStructureService } from './course-structure.service';
+import { CourseVideoAgentPipelineService } from './course-video-agent-pipeline.service';
 import { CourseVideoConversionService } from './course-video-conversion.service';
+import { CourseVideoHlsService } from './course-video-hls.service';
+import { CourseExportScorm12Service } from './course-export-scorm12.service';
+import { CourseExportScorm12WorkerService } from './course-export-scorm12-worker.service';
+import { CourseExportService } from './course-export.service';
 import { CourseController } from './course.controller';
 import { LmsCoursesMcpTools } from './course.mcp-tools';
 import { LmsBulkUploadInfraService } from './lms-bulk-upload-infra.service';
 import { CourseService } from './course.service';
+import { LmsBulkUploadAutomationService } from './lms-bulk-upload-automation.service';
 import { LmsBulkUploadController } from './lms-bulk-upload.controller';
 import { LmsBulkUploadService } from './lms-bulk-upload.service';
 import { LmsOperationsTaskSubscriber } from './lms-operations-task.subscriber';
@@ -24,6 +31,7 @@ import { LmsSettingController } from './lms-setting.controller';
     forwardRef(() => InstructorModule),
     forwardRef(() => CoreModule),
     forwardRef(() => QueueModule),
+    forwardRef(() => AgentModule),
   ],
   controllers: [
     CourseController,
@@ -34,10 +42,16 @@ import { LmsSettingController } from './lms-setting.controller';
     LmsBulkUploadController,
   ],
   providers: [
+    CourseExportService,
+    CourseExportScorm12Service,
+    CourseExportScorm12WorkerService,
     CourseOperationsIntegrationService,
     CourseService,
     CourseStructureService,
+    CourseVideoAgentPipelineService,
     CourseVideoConversionService,
+    CourseVideoHlsService,
+    LmsBulkUploadAutomationService,
     LmsBulkUploadInfraService,
     LmsBulkUploadService,
     LmsCoursesMcpTools,
@@ -47,6 +61,8 @@ import { LmsSettingController } from './lms-setting.controller';
     forwardRef(() => CourseService),
     forwardRef(() => CourseStructureService),
     forwardRef(() => CourseVideoConversionService),
+    forwardRef(() => CourseVideoHlsService),
+    CourseVideoAgentPipelineService,
   ],
 })
 export class CourseModule {}

package/src/course/course.service.ts

@@ -16,8 +16,8 @@ import {
 } from '@nestjs/common';
 import { CourseOperationsIntegrationService } from './course-operations-integration.service';
 import {
-  COURSE_STORAGE_CLEANUP_CATEGORIES,
-  type CourseStorageCleanupCategory,
+    COURSE_STORAGE_CLEANUP_CATEGORIES,
+    type CourseStorageCleanupCategory,
 } from './dto/cleanup-course-storage.dto';
 import { CreateCourseDto } from './dto/create-course.dto';
 import { UpdateCourseDto } from './dto/update-course.dto';
@@ -480,10 +480,12 @@ export class CourseService implements OnModuleInit, IJobHandler {
     ]);
 
     const courseIds = courses.map((course) => course.id);
-    const [extrasById, projectLinksById] = await Promise.all([
-      this.getCourseExtras(courseIds),
-      this.operationsIntegration.getCourseProjectLinks(courseIds),
-    ]);
+    const [extrasById, projectLinksById, coursesWithRunningJobs] =
+      await Promise.all([
+        this.getCourseExtras(courseIds),
+        this.operationsIntegration.getCourseProjectLinks(courseIds),
+        this.getCoursesWithRunningJobs(courseIds),
+      ]);
 
     return {
       total,
@@ -496,6 +498,8 @@ export class CourseService implements OnModuleInit, IJobHandler {
           undefined,
           extrasById.get(c.id),
           projectLinksById.get(c.id),
+          undefined,
+          coursesWithRunningJobs.has(c.id),
         ),
       ),
     };
@@ -1169,6 +1173,7 @@ export class CourseService implements OnModuleInit, IJobHandler {
       course_image: 'Imagens do curso',
       course_file: 'Arquivos do curso',
       other_lesson_file: 'Outros arquivos',
+      course_export: 'Arquivos de exportação',
     };
 
     return labels[category];
@@ -1265,6 +1270,30 @@ export class CourseService implements OnModuleInit, IJobHandler {
       return;
     }
 
+    if (category === 'course_export') {
+      const exports = await this.prisma.course_export.findMany({
+        where: {
+          course_id: courseId,
+          file_id: { not: null },
+          status: { in: ['completed', 'failed'] },
+        },
+        select: { id: true, file_id: true },
+      });
+
+      const fileIds = exports
+        .map((e) => e.file_id)
+        .filter((id): id is number => id != null);
+
+      await this.prisma.course_export.deleteMany({
+        where: { id: { in: exports.map((e) => e.id) } },
+      });
+
+      if (fileIds.length > 0) {
+        await this.fileService.delete('pt', { ids: fileIds }).catch(() => undefined);
+      }
+      return;
+    }
+
     await this.prisma.course_lesson_file.deleteMany({
       where: {
         course_lesson: { course_module: { course_id: courseId } },
@@ -1315,6 +1344,15 @@ export class CourseService implements OnModuleInit, IJobHandler {
         INNER JOIN course_lesson cl ON cl.id = clvf.course_lesson_id
         INNER JOIN course_module cm ON cm.id = cl.course_module_id
         WHERE cm.course_id = ${courseId}
+
+        UNION ALL
+
+        SELECT ce.file_id, f.size AS file_size, 'course_export' AS storage_category
+        FROM course_export ce
+        INNER JOIN file f ON f.id = ce.file_id
+        WHERE ce.course_id = ${courseId}
+          AND ce.status = 'completed'
+          AND ce.file_id IS NOT NULL
       ) AS files
       WHERE files.file_id IS NOT NULL
     `;
@@ -1463,6 +1501,7 @@ export class CourseService implements OnModuleInit, IJobHandler {
         } | null;
       } | null;
     }>,
+    hasRunningJobs = false,
   ) {
     const resolvedName = extras?.name ?? c.name ?? null;
     const resolvedTitle = this.normalizeOptionalText(c.title) ?? c.slug;
@@ -1549,6 +1588,7 @@ export class CourseService implements OnModuleInit, IJobHandler {
         (c.certificate_template_id
           ? String(c.certificate_template_id)
           : null),
+      hasRunningJobs,
       progressByModule: metrics?.progressByModule ?? [],
       instructors: Array.from(
         new Map(
@@ -1624,6 +1664,25 @@ export class CourseService implements OnModuleInit, IJobHandler {
     return extrasById;
   }
 
+  private async getCoursesWithRunningJobs(
+    courseIds: number[],
+  ): Promise<Set<number>> {
+    if (courseIds.length === 0) return new Set();
+
+    const rows = (await this.prisma.$queryRawUnsafe(`
+      SELECT DISTINCT cm.course_id
+      FROM queue_job qj
+      INNER JOIN course_lesson cl ON cl.id = CAST(qj.source_entity_id AS INTEGER)
+      INNER JOIN course_module cm ON cm.id = cl.course_module_id
+      WHERE qj.source_entity = 'course_lesson'
+        AND qj.source_module = 'lms'
+        AND qj.status IN ('pending', 'scheduled', 'processing', 'retrying')
+        AND cm.course_id IN (${courseIds.join(',')})
+    `)) as Array<{ course_id: number }>;
+
+    return new Set(rows.map((r) => Number(r.course_id)));
+  }
+
   private async persistCourseExtras(
     id: number,
     data: PersistCourseExtrasInput,
@@ -1653,7 +1712,8 @@ export class CourseService implements OnModuleInit, IJobHandler {
     }
 
     if (data.offeringType !== undefined) {
-      pushSetClause('offering_type', data.offeringType);
+      values.push(data.offeringType);
+      setClauses.push(`offering_type = $${values.length}::course_offering_type_8af4d2739d_enum`);
     }
 
     if (setClauses.length === 0) {
@@ -1670,8 +1730,8 @@ export class CourseService implements OnModuleInit, IJobHandler {
         `,
         ...values,
       );
-    } catch {
-      // Some environments may still be behind the current course schema.
+    } catch (err) {
+      console.error('[persistCourseExtras] failed:', err);
     }
   }
 
@@ -1836,53 +1896,6 @@ export class CourseService implements OnModuleInit, IJobHandler {
     });
   }
 
-  async getCourseVideoProfiles(courseId: number) {
-    const rows = await (this.prisma as any).course_video_resolution_profile.findMany({
-      where: { course_id: courseId },
-      include: { video_resolution_profile: true },
-      orderBy: { video_resolution_profile: { name: 'asc' } },
-    });
-
-    return (rows as any[]).map((row) => ({
-      id: row.video_resolution_profile.id,
-      name: row.video_resolution_profile.name,
-      ffmpeg_params: row.video_resolution_profile.ffmpeg_params,
-      status: row.video_resolution_profile.status,
-    }));
-  }
-
-  async syncCourseVideoProfiles(courseId: number, profileIds: number[]) {
-    const linkClient = (this.prisma as any).course_video_resolution_profile;
-
-    await this.prisma.$transaction(async (tx: any) => {
-      await tx.course_video_resolution_profile.deleteMany({
-        where: { course_id: courseId },
-      });
-
-      if (profileIds.length > 0) {
-        await tx.course_video_resolution_profile.createMany({
-          data: profileIds.map((id) => ({
-            course_id: courseId,
-            video_resolution_profile_id: id,
-          })),
-        });
-      }
-    });
-
-    return linkClient.findMany({
-      where: { course_id: courseId },
-      include: { video_resolution_profile: true },
-      orderBy: { video_resolution_profile: { name: 'asc' } },
-    }).then((rows: any[]) =>
-      rows.map((row: any) => ({
-        id: row.video_resolution_profile.id,
-        name: row.video_resolution_profile.name,
-        ffmpeg_params: row.video_resolution_profile.ffmpeg_params,
-        status: row.video_resolution_profile.status,
-      })),
-    );
-  }
-
   async getCourseContentOverview(courseId: number) {
     const [
       moduleCount,
@@ -1892,6 +1905,7 @@ export class CourseService implements OnModuleInit, IJobHandler {
       extractedImageCount,
       resourceFileCount,
       storageRows,
+      videoFileRows,
     ] = await Promise.all([
       this.prisma.course_module.count({ where: { course_id: courseId } }),
       this.prisma.course_lesson.findMany({
@@ -1917,6 +1931,17 @@ export class CourseService implements OnModuleInit, IJobHandler {
         },
       }),
       this.getCourseStorageRows(courseId),
+      this.prisma.course_lesson_file.findMany({
+        where: {
+          course_lesson: { course_module: { course_id: courseId } },
+          OR: [
+            { type: 'video_original' },
+            { type: { startsWith: 'video_profile:' } },
+          ],
+          file_id: { not: null },
+        },
+        select: { course_lesson_id: true, type: true },
+      }),
     ]);
 
     const transcriptionLessonIds = new Set(
@@ -1924,10 +1949,23 @@ export class CourseService implements OnModuleInit, IJobHandler {
     );
     const xpLessonIds = new Set(xpMapRows.map((r) => r.course_lesson_id));
 
-    const lessonsByType = { video: 0, questao: 0, post: 0, exercicio: 0 };
+    const videoOriginalLessonIds = new Set(
+      videoFileRows
+        .filter((r) => r.type === 'video_original')
+        .map((r) => r.course_lesson_id),
+    );
+    const videoProfileLessonIds = new Set(
+      videoFileRows
+        .filter((r) => r.type?.startsWith('video_profile:'))
+        .map((r) => r.course_lesson_id),
+    );
+
+    const lessonsByType = { video: 0, questao: 0, post: 0 };
     let publishedLessonCount = 0;
     let videoWithTranscription = 0;
     let videoWithXp = 0;
+    let videoWithVideo = 0;
+    let videoWithProcessedVideo = 0;
 
     const categoryOrder = [
       'video_original',
@@ -1939,6 +1977,7 @@ export class CourseService implements OnModuleInit, IJobHandler {
       'course_image',
       'course_file',
       'other_lesson_file',
+      'course_export',
     ];
 
     const uniqueStorageFiles = new Map<number, number>();
@@ -1995,8 +2034,9 @@ export class CourseService implements OnModuleInit, IJobHandler {
       if (lesson.published) publishedLessonCount++;
 
       let sourceType: string | undefined;
+      let parsed: Record<string, unknown> | null = null;
       try {
-        const parsed = lesson.content
+        parsed = lesson.content
           ? (JSON.parse(lesson.content as string) as Record<string, unknown>)
           : null;
         sourceType =
@@ -2007,12 +2047,11 @@ export class CourseService implements OnModuleInit, IJobHandler {
         // ignore malformed content
       }
 
-      let uiType: 'video' | 'questao' | 'post' | 'exercicio';
+      let uiType: 'video' | 'questao' | 'post';
       if (
         sourceType === 'video' ||
         sourceType === 'questao' ||
-        sourceType === 'post' ||
-        sourceType === 'exercicio'
+        sourceType === 'post'
       ) {
         uiType = sourceType;
       } else if (lesson.type === 'video') {
@@ -2028,6 +2067,23 @@ export class CourseService implements OnModuleInit, IJobHandler {
       if (uiType === 'video') {
         if (transcriptionLessonIds.has(lesson.id)) videoWithTranscription++;
         if (xpLessonIds.has(lesson.id)) videoWithXp++;
+
+        const videoUrl =
+          typeof parsed?.videoUrl === 'string' ? parsed.videoUrl : '';
+        const videoProvedor =
+          typeof parsed?.videoProvedor === 'string'
+            ? parsed.videoProvedor
+            : 'file_storage';
+
+        const hasVideo =
+          videoUrl.length > 0 || videoOriginalLessonIds.has(lesson.id);
+        const isProcessed =
+          videoProvedor !== 'file_storage'
+            ? videoUrl.length > 0
+            : videoProfileLessonIds.has(lesson.id);
+
+        if (hasVideo) videoWithVideo++;
+        if (isProcessed) videoWithProcessedVideo++;
       }
     }
 
@@ -2042,6 +2098,8 @@ export class CourseService implements OnModuleInit, IJobHandler {
         lessonCount: lessonsByType.video,
         withTranscription: videoWithTranscription,
         withXp: videoWithXp,
+        withVideo: videoWithVideo,
+        withProcessedVideo: videoWithProcessedVideo,
       },
       media: { extractedImageCount },
       resources: { fileCount: resourceFileCount },

package/src/course/dto/cleanup-course-storage.dto.ts

@@ -10,6 +10,7 @@ export const COURSE_STORAGE_CLEANUP_CATEGORIES = [
   'course_image',
   'course_file',
   'other_lesson_file',
+  'course_export',
 ] as const;
 
 export type CourseStorageCleanupCategory =

package/src/course/dto/cleanup-upload-history.dto.ts

@@ -1,6 +1,6 @@
 import { ArrayNotEmpty, IsArray, IsIn, IsOptional } from 'class-validator';
 
-export const BULK_UPLOAD_CLEANUP_STATUSES = ['done', 'error', 'cancelled'] as const;
+export const BULK_UPLOAD_CLEANUP_STATUSES = ['received', 'done', 'error', 'cancelled'] as const;
 export const BULK_UPLOAD_CLEANUP_WINDOWS = [
   'last_hour',
   'last_day',

package/src/course/dto/create-course-bulk-job.dto.ts

@@ -1,6 +1,10 @@
-import { IsIn } from 'class-validator';
+import { IsBoolean, IsIn, IsOptional } from 'class-validator';
 
 export class CreateCourseBulkJobDto {
-  @IsIn(['transcription', 'xp_recalculation'])
-  jobType: 'transcription' | 'xp_recalculation';
+  @IsIn(['transcription', 'xp_recalculation', 'video_processing'])
+  jobType: 'transcription' | 'xp_recalculation' | 'video_processing';
+
+  @IsBoolean()
+  @IsOptional()
+  reprocessAlreadyProcessed?: boolean;
 }

package/src/course/dto/create-course-export.dto.ts

@@ -0,0 +1,56 @@
+import { Type } from 'class-transformer';
+import {
+  IsIn,
+  IsInt,
+  IsOptional,
+  IsString,
+  Matches,
+  Max,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+
+export class ScormVisualSettingsDto {
+  @IsOptional()
+  @IsString()
+  @Matches(/^#[0-9a-fA-F]{6}$/, {
+    message: 'primaryColor deve ser uma cor hex válida (ex: #2563eb)',
+  })
+  primaryColor?: string;
+
+  @IsOptional()
+  @IsIn(['system', 'humanist', 'serif', 'mono'])
+  fontFamily?: string;
+
+  @IsOptional()
+  @IsIn(['sm', 'md', 'lg'])
+  fontSize?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(200)
+  @Max(420)
+  sidebarWidth?: number;
+
+  @IsOptional()
+  @IsIn(['left', 'right'])
+  sidebarPosition?: string;
+
+  @IsOptional()
+  @IsIn(['bar', 'pie'])
+  progressStyle?: string;
+
+  @IsOptional()
+  @IsIn(['light', 'dark'])
+  sidebarTheme?: string;
+}
+
+export class CreateCourseExportDto {
+  @IsIn(['scorm_1_2'])
+  format: 'scorm_1_2';
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => ScormVisualSettingsDto)
+  visualSettings?: ScormVisualSettingsDto;
+}

package/src/course/dto/create-course-structure-lesson.dto.ts

@@ -18,10 +18,11 @@ const COURSE_LESSON_FILE_TYPES = [
   'student_download',
   'supplementary_material',
   'video_original',
+  'video_hls',
 ] as const;
 
 const COURSE_LESSON_FILE_TYPE_REGEX =
-  /^(lesson_audio|student_download|supplementary_material|video_original|video_profile:\d+)$/;
+  /^(lesson_audio|student_download|supplementary_material|video_original|video_hls|video_profile:\d+)$/;
 
 export type CourseLessonFileType =
   | (typeof COURSE_LESSON_FILE_TYPES)[number]
@@ -74,8 +75,8 @@ export class CreateCourseStructureLessonDto {
   @IsOptional()
   descricaoPrivada?: string;
 
-  @IsEnum(['video', 'questao', 'post', 'exercicio'])
-  tipo: 'video' | 'questao' | 'post' | 'exercicio';
+  @IsEnum(['video', 'questao', 'post'])
+  tipo: 'video' | 'questao' | 'post';
 
   @IsInt()
   @Min(0)

package/src/course/ffmpeg.util.ts

@@ -0,0 +1,65 @@
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Resolves the ffmpeg/ffprobe binaries across environments: explicit env override first,
+ * then a WinGet (Gyan.FFmpeg) lookup on Windows, finally the bare command on PATH.
+ * Mirrors the resolution baked into CourseVideoHlsService so the decomposed pipeline jobs
+ * (extract / split) behave identically.
+ */
+export function getFfmpegCommand(): string {
+  const fromEnv = process.env.FFMPEG_PATH?.trim();
+  if (fromEnv) return fromEnv;
+  if (process.platform === 'win32') {
+    const found = findWindowsBinary('ffmpeg');
+    if (found) return found;
+  }
+  return 'ffmpeg';
+}
+
+export function getFfprobeCommand(): string {
+  const fromEnv = process.env.FFPROBE_PATH?.trim();
+  if (fromEnv) return fromEnv;
+  const ffmpegEnv = process.env.FFMPEG_PATH?.trim();
+  if (ffmpegEnv) {
+    const candidate = ffmpegEnv.replace(/ffmpeg(\.exe)?$/i, (_, ext) => `ffprobe${ext ?? ''}`);
+    if (existsSync(candidate)) return candidate;
+  }
+  if (process.platform === 'win32') {
+    const found = findWindowsBinary('ffprobe');
+    if (found) return found;
+  }
+  return 'ffprobe';
+}
+
+export function findWindowsBinary(name: 'ffmpeg' | 'ffprobe'): string | null {
+  const localAppData = process.env.LOCALAPPDATA;
+  if (!localAppData) return null;
+  const packagesRoot = join(localAppData, 'Microsoft', 'WinGet', 'Packages');
+  try {
+    const packageDirs = readdirSync(packagesRoot, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && e.name.startsWith('Gyan.FFmpeg'))
+      .map((e) => join(packagesRoot, e.name))
+      .sort((a, b) => b.localeCompare(a));
+
+    for (const dir of packageDirs) {
+      const direct = join(dir, 'bin', `${name}.exe`);
+      if (existsSync(direct)) return direct;
+      try {
+        const versionDirs = readdirSync(dir, { withFileTypes: true })
+          .filter((e) => e.isDirectory() && e.name.toLowerCase().startsWith('ffmpeg-'))
+          .map((e) => join(dir, e.name))
+          .sort((a, b) => b.localeCompare(a));
+        for (const vd of versionDirs) {
+          const candidate = join(vd, 'bin', `${name}.exe`);
+          if (existsSync(candidate)) return candidate;
+        }
+      } catch {
+        /* skip */
+      }
+    }
+  } catch {
+    /* skip */
+  }
+  return null;
+}