@empiricalrun/test-gen 0.75.0 → 0.77.0

package/dist/utils/dedup-image.js

@@ -1,75 +1,20 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deduplicateImages = deduplicateImages;
-const pixelmatch_1 = __importDefault(require("pixelmatch"));
-const sharp_1 = __importDefault(require("sharp"));
-/**
- * Processes an array of base64 image objects and returns only unique images.
- * Two images are considered "similar" if the fraction of differing pixels (when resized)
- * is below the provided threshold.
- *
- * @param options - Configuration options
- * @param options.base64Images - An array of objects, each with a metadata field and a base64-encoded image string.
- * @param options.threshold - The maximum fraction of pixels allowed to differ to consider two images similar.
- *                    For example, 0.01 means that if less than 1% of the pixels differ, the images are considered duplicates.
- *                    Default is 0.001 (0.1%).
- * @param options.logPrefix - The ID of the test run, used for logging purposes.
- * @returns A promise that resolves to an array of unique image objects.
- */
-async function deduplicateImages({ base64Images, threshold = 0.001, logPrefix = "dedup-image", }) {
+const find_threshold_1 = require("./find-threshold");
+async function deduplicateImages({ base64Images, threshold, logPrefix = "dedup-image", }) {
     const uniqueImages = [];
-    // We'll store the raw pixel data (RGBA) and dimensions for the previous unique image.
-    let previousImageData = null;
-    let previousWidth = null;
-    let previousHeight = null;
+    let previousImageBuffer = null;
     for (const imgData of base64Images) {
         try {
-            // Convert the base64 string to a Buffer.
-            const buffer = Buffer.from(imgData.image, "base64");
-            const imgMetadata = await (0, sharp_1.default)(buffer).metadata();
-            const height = imgMetadata.height || 0;
-            const width = imgMetadata.width || 0;
-            // Resize the image to fixed dimensions and extract its raw RGBA pixel data.
-            const { data } = await (0, sharp_1.default)(buffer)
-                .ensureAlpha()
-                .raw()
-                .toBuffer({ resolveWithObject: true });
+            const currentBuffer = Buffer.from(imgData.image, "base64");
             let isDuplicate = false;
-            // If there's a previously processed unique image, compare the current image with it.
-            if (previousImageData &&
-                previousWidth === width &&
-                previousHeight === height) {
-                // Only compare images if they have the same dimensions
-                try {
-                    const diffPixels = (0, pixelmatch_1.default)(data, // current image pixel data
-                    previousImageData, // previous image pixel data
-                    null, // no diff image output is needed
-                    width, height, { threshold: 0.1 });
-                    // console.log("diffPixels", diffPixels);
-                    const totalPixels = height * width;
-                    const diffFraction = diffPixels / totalPixels;
-                    // console.log("diffFraction", diffFraction);
-                    // If the fraction of differing pixels is below (or equal to) the threshold,
-                    // consider the current image a duplicate.
-                    if (diffFraction <= threshold) {
-                        isDuplicate = true;
-                    }
-                }
-                catch (error) {
-                    console.error(`[${logPrefix}] Error comparing images:`, error);
-                    // If comparison fails, treat as non-duplicate
-                    isDuplicate = false;
-                }
+            if (previousImageBuffer) {
+                isDuplicate = await (0, find_threshold_1.areImagesDuplicate)(currentBuffer, previousImageBuffer, threshold);
             }
-            // If the image is not a duplicate, add it to the list and update the previous image data.
             if (!isDuplicate) {
                 uniqueImages.push(imgData);
-                previousImageData = data;
-                previousWidth = width;
-                previousHeight = height;
+                previousImageBuffer = currentBuffer;
             }
         }
         catch (error) {

package/dist/{tools/fetch-video-analysis/local-ffmpeg-client.d.ts → utils/ffmpeg/index.d.ts}

@@ -1,4 +1,4 @@
-import { UniqueFrameWithMetadata } from "@empiricalrun/shared-types";
+import { UniqueFrameInfos } from "@empiricalrun/shared-types";
 export declare class LocalFFmpegClient {
     private static readonly MAX_VIDEO_DURATION_SECONDS;
     private static readonly CHUNK_DURATION_SECONDS;
@@ -6,18 +6,21 @@ export declare class LocalFFmpegClient {
     private checkFFmpegAvailability;
     private getVideoDuration;
     private validateVideoChunk;
-    private downloadVideo;
     private ensureEmptyDir;
     private runFFmpegCommand;
     private createVideoChunks;
-    private extractFramesToFiles;
+    private extractFramesWithFPS;
     private processVideoChunks;
-    extractVideoFrames(videoUrl: string, outputDir: string, options?: {
+    storeUniqueFrames(uniqueFrameInfos: UniqueFrameInfos[], workingDir: string): Promise<string>;
+    extractVideoFrames(videoUrl: string, videoUrlHash: string, absoluteWorkingDir: string, options?: {
         fps?: number;
         threshold?: number;
+        startTime?: number;
+        duration?: number;
     }): Promise<{
         totalFramesCount: number;
-        uniqueFrames: UniqueFrameWithMetadata[];
+        uniqueFrameInfos: UniqueFrameInfos[];
+        videoDurationSeconds: number;
     }>;
 }
-//# sourceMappingURL=local-ffmpeg-client.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/ffmpeg/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/ffmpeg/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAa9D,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAW;IAC7D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAU;;IAMxD,OAAO,CAAC,uBAAuB;YAWjB,gBAAgB;YAiBhB,kBAAkB;YAgClB,cAAc;YASd,gBAAgB;YAoBhB,iBAAiB;YAsEjB,oBAAoB;YAkEpB,kBAAkB;IA8G1B,iBAAiB,CACrB,gBAAgB,EAAE,gBAAgB,EAAE,EACpC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC;IAgFZ,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,OAAO,CAAC,EAAE;QACR,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GACA,OAAO,CAAC;QACT,gBAAgB,EAAE,MAAM,CAAC;QACzB,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;QACrC,oBAAoB,EAAE,MAAM,CAAC;KAC9B,CAAC;CA0IH"}

package/dist/utils/ffmpeg/index.js

@@ -0,0 +1,415 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFFmpegClient = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const constants_1 = require("../../constants");
+const utils_1 = require("../../video-core/utils");
+const dedup_image_fs_1 = require("../dedup-image-fs");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const FRAME_DIMENSION = "1280:720";
+class LocalFFmpegClient {
+    static MAX_VIDEO_DURATION_SECONDS = 15 * 60; // 15 minutes
+    static CHUNK_DURATION_SECONDS = 2 * 60; // 2 minutes
+    constructor() {
+        this.checkFFmpegAvailability();
+    }
+    checkFFmpegAvailability() {
+        try {
+            (0, child_process_1.execSync)("ffmpeg -version", { stdio: "ignore" });
+            (0, child_process_1.execSync)("ffprobe -version", { stdio: "ignore" });
+        }
+        catch (error) {
+            throw new Error(`ffmpeg and ffprobe are required for video processing: ${error}`);
+        }
+    }
+    async getVideoDuration(videoPath) {
+        const command = `ffprobe -v quiet -show_entries format=duration -of csv=p=0 "${videoPath}"`;
+        try {
+            const { stdout } = await execAsync(command);
+            const duration = parseFloat(stdout.trim());
+            if (isNaN(duration)) {
+                throw new Error("Could not determine video duration");
+            }
+            return duration;
+        }
+        catch (error) {
+            throw new Error(`Failed to get video duration: ${error}`);
+        }
+    }
+    async validateVideoChunk(chunkPath) {
+        const command = `ffprobe -v error -show_entries format=duration -of csv=p=0 "${chunkPath}"`;
+        try {
+            const { stdout, stderr } = await execAsync(command);
+            if (stderr && stderr.toLowerCase().includes("error")) {
+                console.warn(`Chunk validation found errors: ${stderr}`);
+                return false;
+            }
+            const duration = parseFloat(stdout.trim());
+            if (isNaN(duration) || duration <= 0) {
+                console.warn(`Chunk has invalid duration: ${duration}`);
+                return false;
+            }
+            // Check file size as additional validation
+            const stats = await fs_1.promises.stat(chunkPath);
+            if (stats.size < 1024) {
+                // Less than 1KB is suspicious for a video chunk
+                console.warn(`Chunk file size too small: ${stats.size} bytes`);
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            console.warn(`Chunk validation failed: ${error}`);
+            return false;
+        }
+    }
+    async ensureEmptyDir(dir) {
+        try {
+            await fs_1.promises.rm(dir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+        await fs_1.promises.mkdir(dir, { recursive: true });
+    }
+    async runFFmpegCommand({ inputPath, args, outputPath, }) {
+        const quotedInput = `"${inputPath}"`;
+        const output = outputPath ? ` "${outputPath}"` : "";
+        const cmd = `ffmpeg -y -nostdin -i ${quotedInput} ${args.join(" ")}${output}`;
+        try {
+            await execAsync(cmd);
+        }
+        catch (error) {
+            throw new Error(`ffmpeg command failed: ${cmd} => ${String(error)}`);
+        }
+    }
+    async createVideoChunks(videoPath, outputDir, duration, startTime = 0) {
+        const chunkPaths = [];
+        const chunkCount = Math.ceil(duration / LocalFFmpegClient.CHUNK_DURATION_SECONDS);
+        console.log(`Creating ${chunkCount} chunks of ${LocalFFmpegClient.CHUNK_DURATION_SECONDS} seconds each`);
+        for (let i = 0; i < chunkCount; i++) {
+            const chunkOffsetTime = i * LocalFFmpegClient.CHUNK_DURATION_SECONDS;
+            const absoluteStartTime = startTime + chunkOffsetTime;
+            const chunkPath = path_1.default.join(outputDir, `chunk_${i.toString().padStart(3, "0")}.mp4`);
+            const remainingDuration = duration - chunkOffsetTime;
+            const chunkDuration = Math.min(LocalFFmpegClient.CHUNK_DURATION_SECONDS, remainingDuration);
+            try {
+                await fs_1.promises.rm(chunkPath, { force: true });
+                await this.runFFmpegCommand({
+                    inputPath: videoPath,
+                    args: [
+                        "-ss",
+                        String(absoluteStartTime),
+                        "-t",
+                        String(chunkDuration),
+                        "-c:v",
+                        "libx264",
+                        "-c:a",
+                        "aac",
+                        "-preset",
+                        "ultrafast",
+                        "-crf",
+                        "28",
+                    ],
+                    outputPath: chunkPath,
+                });
+                // Validate the created chunk
+                const isValid = await this.validateVideoChunk(chunkPath);
+                if (isValid) {
+                    chunkPaths.push(chunkPath);
+                }
+                else {
+                    console.warn(`Chunk ${i} appears corrupted, skipping...`);
+                    try {
+                        await fs_1.promises.unlink(chunkPath);
+                    }
+                    catch (unlinkError) {
+                        console.warn(`Failed to remove corrupted chunk: ${unlinkError}`);
+                    }
+                }
+            }
+            catch (error) {
+                throw new Error(`Failed to create chunk ${i}: ${error}`);
+            }
+        }
+        return chunkPaths;
+    }
+    async extractFramesWithFPS({ videoPath, outputDir, fps, globalStartTime, duration, }) {
+        // Create directory but don't clear it - multiple calls may be appending
+        await fs_1.promises.mkdir(outputDir, { recursive: true });
+        console.log(`Extracting frames at ${fps} fps using single ffmpeg command (${duration ? duration + "s duration" : "full length"}) starting at global time ${globalStartTime}s`);
+        const outputPattern = path_1.default.join(outputDir, "frame_%06d.png");
+        const args = [];
+        if (duration) {
+            args.push("-t", duration.toString());
+        }
+        const vf = `fps=${fps},scale=${FRAME_DIMENSION}:force_original_aspect_ratio=decrease,pad=${FRAME_DIMENSION}:(ow-iw)/2:(oh-ih)/2`;
+        args.push("-vf", `"${vf}"`, "-q:v", "2", "-y");
+        try {
+            await this.runFFmpegCommand({
+                inputPath: videoPath,
+                args: args,
+                outputPath: outputPattern,
+            });
+            const files = await fs_1.promises.readdir(outputDir);
+            const frameFiles = files
+                .filter((f) => f.startsWith("frame_") && f.endsWith(".png"))
+                .sort();
+            const renamedFiles = [];
+            for (let i = 0; i < frameFiles.length; i++) {
+                const originalPath = path_1.default.join(outputDir, frameFiles[i]);
+                const globalFrameNumber = Math.floor(globalStartTime * fps) + i;
+                const newFileName = `chunk0_frame_${globalFrameNumber.toString().padStart(6, "0")}.png`;
+                const newPath = path_1.default.join(outputDir, newFileName);
+                await fs_1.promises.rename(originalPath, newPath);
+                renamedFiles.push(newPath);
+            }
+            console.log(`Successfully extracted ${renamedFiles.length} frames using single ffmpeg command with global frame numbering starting from ${Math.floor(globalStartTime * fps)}`);
+            return renamedFiles;
+        }
+        catch (error) {
+            console.warn(`Failed to extract frames with fps filter:`, error);
+            return [];
+        }
+    }
+    async processVideoChunks(chunkPaths, workingDir, fps, effectiveDuration, globalStartTime = 0) {
+        const allFramePaths = [];
+        const consolidatedFramesDir = path_1.default.join(workingDir, "consolidated_frames");
+        // Check if consolidated_frames directory exists and has frames - if so, append mode
+        const dirExists = await fs_1.promises
+            .access(consolidatedFramesDir)
+            .then(() => true)
+            .catch(() => false);
+        let hasExistingFrames = false;
+        if (dirExists) {
+            try {
+                const existingFiles = await fs_1.promises.readdir(consolidatedFramesDir);
+                hasExistingFrames = existingFiles.some((file) => file.endsWith(".png"));
+            }
+            catch {
+                hasExistingFrames = false;
+            }
+        }
+        if (hasExistingFrames) {
+            // Append mode: directory has frames, don't clear it
+            console.log(`Appending to existing consolidated_frames directory`);
+        }
+        else {
+            // Fresh mode: clear and recreate directory
+            await this.ensureEmptyDir(consolidatedFramesDir);
+            console.log(`Creating fresh consolidated_frames directory`);
+        }
+        for (let i = 0; i < chunkPaths.length; i++) {
+            const chunkPath = chunkPaths[i];
+            const chunkFramesDir = path_1.default.join(workingDir, `chunk_${i}_frames`);
+            console.log(`Processing chunk ${i + 1}/${chunkPaths.length} with precise frame extraction`);
+            if (chunkPath === undefined) {
+                throw new Error(`Chunk path is undefined for chunk ${i + 1}`);
+            }
+            try {
+                const chunkStartTime = i * LocalFFmpegClient.CHUNK_DURATION_SECONDS;
+                const chunkDuration = Math.min(LocalFFmpegClient.CHUNK_DURATION_SECONDS, effectiveDuration - chunkStartTime);
+                const actualGlobalStartTime = globalStartTime + chunkStartTime;
+                const chunkFramePaths = await this.extractFramesWithFPS({
+                    videoPath: chunkPath,
+                    outputDir: chunkFramesDir,
+                    fps,
+                    globalStartTime: actualGlobalStartTime,
+                    duration: chunkDuration,
+                });
+                for (const framePath of chunkFramePaths) {
+                    const basename = path_1.default.basename(framePath);
+                    const frameNumberMatch = basename.match(/frame_(\d+)\.png$/);
+                    const localFrameNumber = frameNumberMatch && frameNumberMatch[1]
+                        ? parseInt(frameNumberMatch[1], 10)
+                        : 0;
+                    const globalFrameNumber = Math.floor(chunkStartTime * fps) + localFrameNumber;
+                    const newFramePath = path_1.default.join(consolidatedFramesDir, `frame_${globalFrameNumber.toString().padStart(6, "0")}.png`);
+                    // In append mode, check if frame already exists
+                    if (hasExistingFrames) {
+                        const frameExists = await fs_1.promises
+                            .access(newFramePath)
+                            .then(() => true)
+                            .catch(() => false);
+                        if (frameExists) {
+                            console.log(`Frame ${newFramePath} already exists, skipping`);
+                            allFramePaths.push(newFramePath);
+                            continue;
+                        }
+                    }
+                    await fs_1.promises.rename(framePath, newFramePath);
+                    allFramePaths.push(newFramePath);
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to process chunk ${i + 1}: ${error}. Skipping this chunk.`);
+                // Continue with other chunks instead of failing completely
+            }
+            if (global.gc) {
+                global.gc();
+            }
+        }
+        return allFramePaths;
+    }
+    async storeUniqueFrames(uniqueFrameInfos, workingDir) {
+        const uniqueFramesDir = path_1.default.join(workingDir, "unique_frames");
+        // Check if directory exists and has frames - if so, append mode
+        const dirExists = await fs_1.promises
+            .access(uniqueFramesDir)
+            .then(() => true)
+            .catch(() => false);
+        let hasExistingFrames = false;
+        if (dirExists) {
+            try {
+                const existingFiles = await fs_1.promises.readdir(uniqueFramesDir);
+                hasExistingFrames = existingFiles.some((file) => file.endsWith(".png"));
+            }
+            catch {
+                hasExistingFrames = false;
+            }
+        }
+        if (hasExistingFrames) {
+            // Append mode: directory has frames, don't clear it
+            console.log(`Appending ${uniqueFrameInfos.length} frames to existing ${uniqueFramesDir}`);
+        }
+        else {
+            // Fresh mode: clear and recreate directory
+            await this.ensureEmptyDir(uniqueFramesDir);
+            console.log(`Creating fresh ${uniqueFramesDir} with ${uniqueFrameInfos.length} frames`);
+        }
+        console.log(`Storing ${uniqueFrameInfos.length} unique frames in ${uniqueFramesDir}`);
+        for (let i = 0; i < uniqueFrameInfos.length; i++) {
+            const frame = uniqueFrameInfos[i];
+            if (!frame)
+                continue;
+            const originalPath = frame.path;
+            const originalBasename = path_1.default.basename(originalPath);
+            const frameNumberMatch = originalBasename.match(/frame_(\d+)\.png$/);
+            const frameNumber = frameNumberMatch
+                ? frameNumberMatch[1]
+                : i.toString().padStart(6, "0");
+            const uniqueFramePath = path_1.default.join(uniqueFramesDir, `frame_${frameNumber}.png`);
+            try {
+                // In append mode, check if frame already exists to avoid overwriting
+                if (hasExistingFrames) {
+                    const frameExists = await fs_1.promises
+                        .access(uniqueFramePath)
+                        .then(() => true)
+                        .catch(() => false);
+                    if (frameExists) {
+                        console.log(`Frame ${uniqueFramePath} already exists, skipping`);
+                        continue;
+                    }
+                }
+                await fs_1.promises.copyFile(originalPath, uniqueFramePath);
+            }
+            catch (error) {
+                console.warn(`Failed to copy frame ${originalPath} to ${uniqueFramePath}:`, error);
+            }
+        }
+        console.log(`Stored ${uniqueFrameInfos.length} unique frames in: ${uniqueFramesDir}`);
+        return uniqueFramesDir;
+    }
+    async extractVideoFrames(videoUrl, videoUrlHash, absoluteWorkingDir, options) {
+        console.log("🚀 ~ LocalFFmpegClient ~ using absolute workingDir:", absoluteWorkingDir);
+        const workingDir = absoluteWorkingDir;
+        const urlHash = node_crypto_1.default
+            .createHash("sha256")
+            .update(videoUrl)
+            .digest("hex")
+            .substring(0, 16);
+        const videoPath = path_1.default.join(workingDir, `video_${urlHash}.webm`);
+        const fps = options?.fps ?? 30;
+        const threshold = options?.threshold ?? 0.001;
+        const startTime = options?.startTime;
+        const duration = options?.duration;
+        try {
+            await fs_1.promises.mkdir(workingDir, { recursive: true });
+            await (0, utils_1.downloadVideo)(videoUrl, videoPath);
+            const videoDuration = await this.getVideoDuration(videoPath);
+            console.log(`Video duration: ${Math.round(videoDuration)} seconds`);
+            if (videoDuration > LocalFFmpegClient.MAX_VIDEO_DURATION_SECONDS) {
+                throw new Error(`Video duration (${Math.round(videoDuration)}s) exceeds maximum allowed duration (${LocalFFmpegClient.MAX_VIDEO_DURATION_SECONDS}s)`);
+            }
+            // Validate and adjust time parameters
+            let effectiveStartTime = 0;
+            let effectiveDuration = videoDuration;
+            if (startTime !== undefined) {
+                if (startTime < 0) {
+                    throw new Error(`Start time cannot be negative: ${startTime}`);
+                }
+                if (startTime >= videoDuration) {
+                    throw new Error(`Start time (${startTime}s) exceeds video duration (${Math.round(videoDuration)}s)`);
+                }
+                effectiveStartTime = startTime;
+                effectiveDuration = videoDuration - startTime;
+            }
+            if (duration !== undefined) {
+                if (duration <= 0) {
+                    throw new Error(`Duration must be positive: ${duration}`);
+                }
+                const maxAllowedDuration = videoDuration - effectiveStartTime;
+                if (duration > maxAllowedDuration) {
+                    console.warn(`Requested duration (${duration}s) exceeds available time (${maxAllowedDuration}s), truncating to fit`);
+                    effectiveDuration = maxAllowedDuration;
+                }
+                else {
+                    effectiveDuration = duration;
+                }
+            }
+            console.log(`Effective extraction range: ${effectiveStartTime}s to ${effectiveStartTime + effectiveDuration}s`);
+            const chunkPaths = await this.createVideoChunks(videoPath, workingDir, effectiveDuration, effectiveStartTime);
+            const allFramePaths = await this.processVideoChunks(chunkPaths, workingDir, fps, effectiveDuration, // Pass duration for precise calculations
+            effectiveStartTime);
+            const allFramesCount = allFramePaths.length;
+            const uniqueImages = await (0, dedup_image_fs_1.deduplicateImageFiles)({
+                imagePaths: allFramePaths,
+                batchSize: 50,
+                threshold,
+                logPrefix: "ffmpeg-chunk-frame-dedup",
+            });
+            console.log(`Filtered to ${uniqueImages.length} unique frames from ${allFramesCount} total frames across ${chunkPaths.length} chunks`);
+            if (uniqueImages.length === 0) {
+                if (chunkPaths.length === 0) {
+                    throw new Error("No valid video chunks were created. The video may be corrupted or in an unsupported format.");
+                }
+                throw new Error("No frames were extracted from the video");
+            }
+            const uniqueFrameInfos = uniqueImages.map((f) => {
+                const normalizedIndex = f.metadata.index
+                    .toString()
+                    .padStart(constants_1.VIDEO_ANALYSIS.FRAME_INDEX_PADDING, "0");
+                const timeInSeconds = f.metadata.index / fps;
+                const minutes = Math.floor(timeInSeconds / 60);
+                const seconds = Math.floor(timeInSeconds % 60);
+                const timestamp = `${minutes}m${seconds.toString().padStart(2, "0")}s`;
+                const fileName = `frame_${normalizedIndex}.png`;
+                return {
+                    index: f.metadata.index,
+                    path: f.metadata.path,
+                    fileName: fileName,
+                    base64: f.image,
+                    url: `${(0, utils_1.getR2BaseUrlByHash)(videoUrlHash)}${fileName}`,
+                    timestamp: timestamp,
+                };
+            });
+            await this.storeUniqueFrames(uniqueFrameInfos, workingDir);
+            return {
+                totalFramesCount: allFramesCount,
+                uniqueFrameInfos,
+                videoDurationSeconds: videoDuration,
+            };
+        }
+        catch (error) {
+            throw new Error(`Frame extraction failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+exports.LocalFFmpegClient = LocalFFmpegClient;

package/dist/utils/file.d.ts

@@ -1,2 +1,3 @@
+export declare const safeCleanupDirectory: (dirPath: string, label?: string) => Promise<void>;
 export declare function findFileRecursively(directory: string, fileName: string): string | undefined;
 //# sourceMappingURL=file.d.ts.map

package/dist/utils/file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/utils/file.ts"],"names":[],"mappings":"AAGA,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAgBpB"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/utils/file.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,cAAiB,KAChB,OAAO,CAAC,IAAI,CAUd,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAgBpB"}

package/dist/utils/file.js

@@ -1,11 +1,55 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeCleanupDirectory = void 0;
 exports.findFileRecursively = findFileRecursively;
-const fs_1 = __importDefault(require("fs"));
+const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
+const safeCleanupDirectory = async (dirPath, label = "cleanup") => {
+    try {
+        console.log(`[${label}] Cleaning up directory: ${dirPath}`);
+        await fs_1.promises.rm(dirPath, { recursive: true });
+    }
+    catch (error) {
+        console.warn(`[${label}] Failed to cleanup directory ${dirPath}:`, error instanceof Error ? error.message : String(error));
+    }
+};
+exports.safeCleanupDirectory = safeCleanupDirectory;
 function findFileRecursively(directory, fileName) {
     const files = fs_1.default.readdirSync(directory);
     for (const file of files) {

package/dist/utils/find-threshold.d.ts

@@ -0,0 +1,8 @@
+export declare function compareImageBuffers(buffer1: Buffer, buffer2: Buffer, pixelmatchThreshold: number): Promise<{
+    diffPixels: number;
+    totalPixels: number;
+    diffFraction: number;
+}>;
+export declare function findSimilarityPercentage(base64Image1: string, base64Image2: string): Promise<number>;
+export declare function areImagesDuplicate(buffer1: Buffer, buffer2: Buffer, threshold: number): Promise<boolean>;
+//# sourceMappingURL=find-threshold.d.ts.map

package/dist/utils/find-threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-threshold.d.ts","sourceRoot":"","sources":["../../src/utils/find-threshold.ts"],"names":[],"mappings":"AAKA,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CA6B5E;AAED,wBAAsB,wBAAwB,CAC5C,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAYlB"}

package/dist/utils/find-threshold.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareImageBuffers = compareImageBuffers;
+exports.findSimilarityPercentage = findSimilarityPercentage;
+exports.areImagesDuplicate = areImagesDuplicate;
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const sharp_1 = __importDefault(require("sharp"));
+const PIXELMATCH_THRESHOLD = 0.1;
+async function compareImageBuffers(buffer1, buffer2, pixelmatchThreshold) {
+    const metadata1 = await (0, sharp_1.default)(buffer1).metadata();
+    const metadata2 = await (0, sharp_1.default)(buffer2).metadata();
+    const width = metadata1.width || 0;
+    const height = metadata1.height || 0;
+    if (width !== (metadata2.width || 0) || height !== (metadata2.height || 0)) {
+        throw new Error("Images must have the same dimensions for comparison");
+    }
+    const { data: data1 } = await (0, sharp_1.default)(buffer1)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const { data: data2 } = await (0, sharp_1.default)(buffer2)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const diffPixels = (0, pixelmatch_1.default)(data1, data2, null, width, height, {
+        threshold: pixelmatchThreshold,
+    });
+    const totalPixels = width * height;
+    const diffFraction = diffPixels / totalPixels;
+    return { diffPixels, totalPixels, diffFraction };
+}
+async function findSimilarityPercentage(base64Image1, base64Image2) {
+    try {
+        const buffer1 = Buffer.from(base64Image1, "base64");
+        const buffer2 = Buffer.from(base64Image2, "base64");
+        const { diffFraction } = await compareImageBuffers(buffer1, buffer2, 0.1);
+        return diffFraction;
+    }
+    catch (error) {
+        throw new Error(`Error calculating similarity: ${error}`);
+    }
+}
+async function areImagesDuplicate(buffer1, buffer2, threshold) {
+    try {
+        const { diffFraction } = await compareImageBuffers(buffer1, buffer2, PIXELMATCH_THRESHOLD);
+        return diffFraction <= threshold;
+    }
+    catch (error) {
+        console.error("Error comparing images for duplication:", error);
+        return false;
+    }
+}