@empiricalrun/test-gen 0.77.0 → 0.78.1

package/dist/utils/artifact-paths.d.ts

@@ -1,20 +0,0 @@
-/**
- * root/ (= baseArtifactDir)
- *  - video_<videoUrlHash>.webm (= videoFile)
- *  - chunk_1.mp4
- *  - consolidated_frames/ (= consolidatedFramesDir)
- *     - frame_0001.png
- *     - frame_0002.png
- *     - ...
- *  - unique_frames/ (= uniqueFramesDir)
- *     - frame_0002.png
- *     - ...
- */
-export interface VideoArtifactPaths {
-    baseArtifactDir: string;
-    videoFile: string;
-    consolidatedFramesDir: string;
-    uniqueFramesDir: string;
-}
-export declare function resolveVideoArtifactPaths(artifactsPath: string, videoUrlHash: string): VideoArtifactPaths;
-//# sourceMappingURL=artifact-paths.d.ts.map

package/dist/utils/artifact-paths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"artifact-paths.d.ts","sourceRoot":"","sources":["../../src/utils/artifact-paths.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,kBAAkB;IAEjC,eAAe,EAAE,MAAM,CAAC;IAExB,SAAS,EAAE,MAAM,CAAC;IAElB,qBAAqB,EAAE,MAAM,CAAC;IAE9B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,kBAAkB,CAQpB"}

package/dist/utils/artifact-paths.js

@@ -1,16 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVideoArtifactPaths = resolveVideoArtifactPaths;
-const node_path_1 = __importDefault(require("node:path"));
-function resolveVideoArtifactPaths(artifactsPath, videoUrlHash) {
-    const baseArtifactDir = artifactsPath;
-    return {
-        baseArtifactDir,
-        videoFile: node_path_1.default.join(baseArtifactDir, `video_${videoUrlHash}.webm`),
-        consolidatedFramesDir: node_path_1.default.join(baseArtifactDir, "consolidated_frames"),
-        uniqueFramesDir: node_path_1.default.join(baseArtifactDir, "unique_frames"),
-    };
-}

package/dist/utils/dedup-image-fs.d.ts

@@ -1,13 +0,0 @@
-export declare function deduplicateImageFiles({ imagePaths, batchSize, threshold, logPrefix, }: {
-    imagePaths: string[];
-    batchSize: number;
-    threshold: number;
-    logPrefix?: string;
-}): Promise<{
-    metadata: {
-        index: number;
-        path: string;
-    };
-    image: string;
-}[]>;
-//# sourceMappingURL=dedup-image-fs.d.ts.map

package/dist/utils/dedup-image-fs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dedup-image-fs.d.ts","sourceRoot":"","sources":["../../src/utils/dedup-image-fs.ts"],"names":[],"mappings":"AAKA,wBAAsB,qBAAqB,CAAC,EAC1C,UAAU,EACV,SAAS,EACT,SAAS,EACT,SAA4B,GAC7B,EAAE;IACD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CA2G1E"}

package/dist/utils/dedup-image-fs.js

@@ -1,84 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deduplicateImageFiles = deduplicateImageFiles;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const dedup_image_1 = require("./dedup-image");
-async function deduplicateImageFiles({ imagePaths, batchSize, threshold, logPrefix = "dedup-image-fs", }) {
-    const uniqueImages = [];
-    console.log(`[${logPrefix}] Processing ${imagePaths.length} images in batches of ${batchSize}`);
-    for (let i = 0; i < imagePaths.length; i += batchSize) {
-        const batch = imagePaths.slice(i, i + batchSize);
-        console.log(`[${logPrefix}] Processing batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(imagePaths.length / batchSize)}`);
-        const batchBase64Images = [];
-        for (let j = 0; j < batch.length; j++) {
-            const imagePath = batch[j];
-            if (!imagePath) {
-                console.error(`[${logPrefix}] Error: imagePath is undefined for batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(imagePaths.length / batchSize)}`);
-                continue;
-            }
-            try {
-                const buffer = await fs_1.promises.readFile(imagePath);
-                const base64 = buffer.toString("base64");
-                // Extract actual frame number from filename instead of using serial index
-                const filename = path_1.default.basename(imagePath);
-                const frameNumberMatch = filename.match(/frame_(\d+)\.png$/);
-                const frameIndex = frameNumberMatch
-                    ? parseInt(frameNumberMatch[1], 10)
-                    : i + j; // Fallback to serial index if no match
-                batchBase64Images.push({
-                    metadata: {
-                        index: frameIndex,
-                        path: imagePath,
-                    },
-                    image: base64,
-                });
-            }
-            catch (error) {
-                console.error(`[${logPrefix}] Error reading image ${imagePath}:`, error);
-                continue;
-            }
-        }
-        // If this is the first batch, just deduplicate within the batch
-        if (uniqueImages.length === 0) {
-            const batchUniqueImages = await (0, dedup_image_1.deduplicateImages)({
-                base64Images: batchBase64Images,
-                threshold,
-                logPrefix: `${logPrefix}-batch-${Math.floor(i / batchSize) + 1}`,
-            });
-            uniqueImages.push(...batchUniqueImages);
-        }
-        else {
-            // For subsequent batches, compare against the last unique image and then deduplicate within batch
-            const lastUniqueImage = uniqueImages[uniqueImages.length - 1];
-            if (!lastUniqueImage) {
-                console.error(`[${logPrefix}] Error: lastUniqueImage is undefined for batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(imagePaths.length / batchSize)}`);
-                continue;
-            }
-            const batchWithPrevious = [lastUniqueImage, ...batchBase64Images];
-            const batchUniqueImages = await (0, dedup_image_1.deduplicateImages)({
-                base64Images: batchWithPrevious,
-                threshold,
-                logPrefix: `${logPrefix}-batch-${Math.floor(i / batchSize) + 1}`,
-            });
-            // Remove the first image if it's the same as the last unique image (it was a duplicate)
-            // and add the rest to unique images
-            if (batchUniqueImages.length > 0) {
-                // Skip the first image if it has the same path as the last unique image
-                const startIndex = batchUniqueImages[0]?.metadata.path === lastUniqueImage.metadata.path
-                    ? 1
-                    : 0;
-                uniqueImages.push(...batchUniqueImages.slice(startIndex));
-            }
-        }
-        // Force garbage collection after each batch
-        if (global.gc) {
-            global.gc();
-        }
-    }
-    console.log(`[${logPrefix}] Filtered to ${uniqueImages.length} unique images from ${imagePaths.length} total images`);
-    return uniqueImages;
-}

package/dist/utils/dedup-image.d.ts

@@ -1,12 +0,0 @@
-export declare function deduplicateImages({ base64Images, threshold, logPrefix, }: {
-    base64Images: {
-        metadata: any;
-        image: string;
-    }[];
-    threshold: number;
-    logPrefix?: string;
-}): Promise<{
-    metadata: any;
-    image: string;
-}[]>;
-//# sourceMappingURL=dedup-image.d.ts.map

package/dist/utils/dedup-image.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dedup-image.d.ts","sourceRoot":"","sources":["../../src/utils/dedup-image.ts"],"names":[],"mappings":"AAEA,wBAAsB,iBAAiB,CAAC,EACtC,YAAY,EACZ,SAAS,EACT,SAAyB,GAC1B,EAAE;IACD,YAAY,EAAE;QAAE,QAAQ,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CA0B9C"}

package/dist/utils/dedup-image.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deduplicateImages = deduplicateImages;
-const find_threshold_1 = require("./find-threshold");
-async function deduplicateImages({ base64Images, threshold, logPrefix = "dedup-image", }) {
-    const uniqueImages = [];
-    let previousImageBuffer = null;
-    for (const imgData of base64Images) {
-        try {
-            const currentBuffer = Buffer.from(imgData.image, "base64");
-            let isDuplicate = false;
-            if (previousImageBuffer) {
-                isDuplicate = await (0, find_threshold_1.areImagesDuplicate)(currentBuffer, previousImageBuffer, threshold);
-            }
-            if (!isDuplicate) {
-                uniqueImages.push(imgData);
-                previousImageBuffer = currentBuffer;
-            }
-        }
-        catch (error) {
-            console.error(`[${logPrefix}] Error processing image:`, error);
-        }
-    }
-    return uniqueImages;
-}

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

@@ -1,26 +0,0 @@
-import { UniqueFrameInfos } from "@empiricalrun/shared-types";
-export declare class LocalFFmpegClient {
-    private static readonly MAX_VIDEO_DURATION_SECONDS;
-    private static readonly CHUNK_DURATION_SECONDS;
-    constructor();
-    private checkFFmpegAvailability;
-    private getVideoDuration;
-    private validateVideoChunk;
-    private ensureEmptyDir;
-    private runFFmpegCommand;
-    private createVideoChunks;
-    private extractFramesWithFPS;
-    private processVideoChunks;
-    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;
-        uniqueFrameInfos: UniqueFrameInfos[];
-        videoDurationSeconds: number;
-    }>;
-}
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,415 +0,0 @@
-"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/find-threshold.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/video-core/agent-orchestrator.d.ts

@@ -1,14 +0,0 @@
-import type { Attachment, CanonicalMessage, ChatState, SupportedChatModels } from "@empiricalrun/shared-types";
-import { ProcessedAnalysis } from "./types";
-export declare function extractTextPartFromLastMessage(messages: CanonicalMessage[]): string | null;
-export declare function getChatStateWithFrameIdAttachmentParts(attachments: Attachment[], selectedModel: SupportedChatModels): ChatState;
-export declare function orchestrateVideoAnalysis({ selectedModel, featureFlags, workingDirectory, frameBatch, }: {
-    selectedModel: SupportedChatModels;
-    featureFlags: string[];
-    workingDirectory: string;
-    frameBatch: Attachment[];
-}): Promise<{
-    analysis: string;
-    allMessages: CanonicalMessage[];
-} & ProcessedAnalysis>;
-//# sourceMappingURL=agent-orchestrator.d.ts.map