ugly-app 0.1.241 → 0.1.242

package/dist/cli/version.d.ts

@@ -1,2 +1,2 @@
-export declare const CLI_VERSION = "0.1.241";
+export declare const CLI_VERSION = "0.1.242";
 //# sourceMappingURL=version.d.ts.map

package/dist/cli/version.js

@@ -1,3 +1,3 @@
 // Auto-generated by prebuild — do not edit manually
-export const CLI_VERSION = "0.1.241";
+export const CLI_VERSION = "0.1.242";
 //# sourceMappingURL=version.js.map

package/dist/three/client/index.d.ts

@@ -0,0 +1,3 @@
+export { PostProcessingManager, } from '../shared/PostProcessing.js';
+export { DynamicCameraController, } from '../shared/CameraController.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/three/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/three/client/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,qBAAqB,GACtB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,uBAAuB,GACxB,MAAM,+BAA+B,CAAC"}

package/dist/three/client/index.js

@@ -0,0 +1,5 @@
+// Client-side Three.js utilities
+// Currently re-exports shared modules that work in browser context
+export { PostProcessingManager, } from '../shared/PostProcessing.js';
+export { DynamicCameraController, } from '../shared/CameraController.js';
+//# sourceMappingURL=index.js.map

package/dist/three/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/three/client/index.ts"],"names":[],"mappings":"AAAA,iCAAiC;AACjC,mEAAmE;AAEnE,OAAO,EACL,qBAAqB,GACtB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,uBAAuB,GACxB,MAAM,+BAA+B,CAAC"}

package/dist/three/server/VideoEncoder.d.ts

@@ -0,0 +1,132 @@
+/**
+ * VideoEncoder - FFmpeg-based video encoding for server-side rendering
+ *
+ * Handles:
+ * - Receiving raw RGBA frames from AvatarScene.captureFrameResult()
+ * - Encoding to H.264/MP4 via FFmpeg
+ * - Muxing with audio (MP3/PCM)
+ * - Output to file or buffer
+ */
+declare let captureServerError: (msg: string, err: unknown, ctx?: Record<string, unknown>) => void;
+export declare function setVideoEncoderErrorHandler(handler: typeof captureServerError): void;
+/**
+ * Check if the FFmpeg `ass` filter (libass) is available.
+ * Result is cached for the lifetime of the process.
+ */
+export declare function checkLibassAvailable(): Promise<boolean>;
+/**
+ * Check if NVIDIA NVENC hardware encoder is available.
+ * Result is cached for the lifetime of the process.
+ */
+export declare function checkNvencAvailable(): Promise<boolean>;
+export interface VideoEncoderOptions {
+    /** Output width in pixels */
+    width: number;
+    /** Output height in pixels */
+    height: number;
+    /** Frames per second (default: 30) */
+    fps?: number;
+    /** Video bitrate (default: '4M') */
+    videoBitrate?: string;
+    /** Audio bitrate (default: '192k') */
+    audioBitrate?: string;
+    /** Output format (default: 'mp4') */
+    outputFormat?: 'mp4' | 'webm';
+    /** Output file path (if not provided, uses temp file) */
+    outputPath?: string;
+    /** Audio input file path (optional - will be muxed with video) */
+    audioPath?: string;
+    /** H.264 encoding preset (default: 'fast') */
+    preset?: 'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium';
+    /** CRF quality (0-51, default: 23, lower = better quality) */
+    crf?: number;
+    /** Path to ASS subtitle file to burn into the video */
+    subtitlePath?: string;
+}
+export interface VideoEncoderStats {
+    framesWritten: number;
+    bytesWritten: number;
+    durationMs: number;
+}
+/**
+ * FFmpeg-based video encoder for server-side avatar rendering.
+ *
+ * Usage:
+ * ```typescript
+ * const encoder = new VideoEncoder({
+ *   width: 1280,
+ *   height: 720,
+ *   fps: 30,
+ *   audioPath: '/path/to/audio.mp3',
+ * });
+ *
+ * await encoder.start();
+ *
+ * // For each frame:
+ * const result = scene.captureFrameResult();
+ * if (result.type === 'raw') {
+ *   encoder.writeFrame(result.raw!);
+ * }
+ *
+ * const output = await encoder.finalize();
+ * // output.buffer contains the MP4 data
+ * // output.path contains the temp file path
+ * ```
+ */
+export declare class VideoEncoder {
+    private options;
+    private ffmpeg;
+    private outputPath;
+    private framesWritten;
+    private startTime;
+    private isFinalized;
+    private stderrOutput;
+    private useNvenc;
+    private ffmpegExitPromise;
+    constructor(options: VideoEncoderOptions);
+    /**
+     * Start the FFmpeg encoding process.
+     */
+    start(): Promise<void>;
+    /**
+     * Build FFmpeg command arguments.
+     */
+    private buildFFmpegArgs;
+    /**
+     * Write a frame to the encoder.
+     *
+     * @param rgba - Raw RGBA pixel data (Uint8Array from captureFrameResult)
+     * @returns Promise that resolves when frame is written (handles backpressure)
+     */
+    writeFrame(rgba: Uint8Array): Promise<void>;
+    /**
+     * Finalize encoding and return the output.
+     */
+    finalize(): Promise<{
+        buffer: Buffer;
+        path: string;
+        stats: VideoEncoderStats;
+    }>;
+    /**
+     * Abort encoding and clean up.
+     */
+    abort(): void;
+    /**
+     * Get encoding statistics.
+     */
+    getStats(): VideoEncoderStats;
+    /**
+     * Clean up the output file (call after uploading to storage).
+     */
+    cleanup(): void;
+}
+/**
+ * Check if FFmpeg is available on the system.
+ */
+export declare function checkFFmpegAvailable(): Promise<boolean>;
+/**
+ * Get FFmpeg version string.
+ */
+export declare function getFFmpegVersion(): Promise<string | null>;
+export {};
+//# sourceMappingURL=VideoEncoder.d.ts.map

package/dist/three/server/VideoEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoEncoder.d.ts","sourceRoot":"","sources":["../../../src/three/server/VideoEncoder.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAMH,QAAA,IAAI,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IACrC,CAAC;AAElD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,kBAAkB,GAAG,IAAI,CAEpF;AAgBD;;;GAGG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CA4C7D;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,OAAO,CAAC,CAmD5D;AAMD,MAAM,WAAW,mBAAmB;IAClC,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,YAAY,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC9B,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,MAAM,CAAC,EACH,WAAW,GACX,WAAW,GACX,UAAU,GACV,QAAQ,GACR,MAAM,GACN,QAAQ,CAAC;IACb,8DAA8D;IAC9D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAMb;IAEF,OAAO,CAAC,MAAM,CAA+C;IAC7D,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,iBAAiB,CAGR;gBAEL,OAAO,EAAE,mBAAmB;IA2BxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAiF5B;;OAEG;IACH,OAAO,CAAC,eAAe;IA2IvB;;;;;OAKG;IACG,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAwEjD;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC;QACxB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,iBAAiB,CAAC;KAC1B,CAAC;IA8DF;;OAEG;IACH,KAAK,IAAI,IAAI;IAcb;;OAEG;IACH,QAAQ,IAAI,iBAAiB;IAQ7B;;OAEG;IACH,OAAO,IAAI,IAAI;CAKhB;AAMD;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAU7D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAwB/D"}

package/dist/three/server/VideoEncoder.js

@@ -0,0 +1,512 @@
+// @ts-nocheck — Lifted from main app; generalized for ugly-app/three
+/**
+ * VideoEncoder - FFmpeg-based video encoding for server-side rendering
+ *
+ * Handles:
+ * - Receiving raw RGBA frames from AvatarScene.captureFrameResult()
+ * - Encoding to H.264/MP4 via FFmpeg
+ * - Muxing with audio (MP3/PCM)
+ * - Output to file or buffer
+ */
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+// Error handler — defaults to console.error, can be overridden
+let captureServerError = (msg, err, ctx) => console.error(msg, err, ctx);
+export function setVideoEncoderErrorHandler(handler) {
+    captureServerError = handler;
+}
+// ============================================================================
+// NVENC Detection (cached)
+// ============================================================================
+let nvencAvailable = null;
+let nvencCheckPromise = null;
+// ============================================================================
+// libass Detection (cached)
+// ============================================================================
+let libassAvailable = null;
+let libassCheckPromise = null;
+/**
+ * Check if the FFmpeg `ass` filter (libass) is available.
+ * Result is cached for the lifetime of the process.
+ */
+export async function checkLibassAvailable() {
+    if (libassAvailable !== null) {
+        return libassAvailable;
+    }
+    if (libassCheckPromise) {
+        return libassCheckPromise;
+    }
+    libassCheckPromise = new Promise((resolve) => {
+        const ffmpeg = spawn('ffmpeg', ['-filters']);
+        let output = '';
+        ffmpeg.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        ffmpeg.on('close', () => {
+            libassAvailable = output.includes('ass');
+            if (libassAvailable) {
+                console.log('[VideoEncoder] libass subtitle filter available');
+            }
+            else {
+                console.warn('[VideoEncoder] libass not available — ASS subtitle burn-in disabled. Install ffmpeg-full: brew install ffmpeg-full');
+            }
+            resolve(libassAvailable);
+        });
+        ffmpeg.on('error', () => {
+            libassAvailable = false;
+            resolve(false);
+        });
+        setTimeout(() => {
+            if (libassAvailable === null) {
+                ffmpeg.kill();
+                libassAvailable = false;
+                resolve(false);
+            }
+        }, 5000);
+    });
+    return libassCheckPromise;
+}
+/**
+ * Check if NVIDIA NVENC hardware encoder is available.
+ * Result is cached for the lifetime of the process.
+ */
+export async function checkNvencAvailable() {
+    if (nvencAvailable !== null) {
+        return nvencAvailable;
+    }
+    if (nvencCheckPromise) {
+        return nvencCheckPromise;
+    }
+    nvencCheckPromise = new Promise((resolve) => {
+        // Try to run ffmpeg with h264_nvenc to see if it's available
+        const ffmpeg = spawn('ffmpeg', [
+            '-f',
+            'lavfi',
+            '-i',
+            'nullsrc=s=256x256:d=0.1',
+            '-c:v',
+            'h264_nvenc',
+            '-f',
+            'null',
+            '-',
+        ]);
+        ffmpeg.on('close', (code) => {
+            nvencAvailable = code === 0;
+            if (nvencAvailable) {
+                console.log('[VideoEncoder] NVENC hardware encoder available');
+            }
+            else {
+                console.log('[VideoEncoder] NVENC not available, using CPU encoding (libx264)');
+            }
+            resolve(nvencAvailable);
+        });
+        ffmpeg.on('error', () => {
+            nvencAvailable = false;
+            resolve(false);
+        });
+        // Timeout after 5 seconds
+        setTimeout(() => {
+            if (nvencAvailable === null) {
+                ffmpeg.kill();
+                nvencAvailable = false;
+                resolve(false);
+            }
+        }, 5000);
+    });
+    return nvencCheckPromise;
+}
+// ============================================================================
+// VideoEncoder Class
+// ============================================================================
+/**
+ * FFmpeg-based video encoder for server-side avatar rendering.
+ *
+ * Usage:
+ * ```typescript
+ * const encoder = new VideoEncoder({
+ *   width: 1280,
+ *   height: 720,
+ *   fps: 30,
+ *   audioPath: '/path/to/audio.mp3',
+ * });
+ *
+ * await encoder.start();
+ *
+ * // For each frame:
+ * const result = scene.captureFrameResult();
+ * if (result.type === 'raw') {
+ *   encoder.writeFrame(result.raw!);
+ * }
+ *
+ * const output = await encoder.finalize();
+ * // output.buffer contains the MP4 data
+ * // output.path contains the temp file path
+ * ```
+ */
+export class VideoEncoder {
+    options;
+    ffmpeg = null;
+    outputPath;
+    framesWritten = 0;
+    startTime = 0;
+    isFinalized = false;
+    stderrOutput = '';
+    useNvenc = false;
+    ffmpegExitPromise = null;
+    constructor(options) {
+        // Generate temp output path if not provided
+        const tempDir = process.env.TEMP_DIR || '/tmp';
+        const outputPath = options.outputPath ||
+            path.join(tempDir, `video-${Date.now()}-${Math.random().toString(36).slice(2)}.mp4`);
+        this.options = {
+            width: options.width,
+            height: options.height,
+            fps: options.fps ?? 30,
+            videoBitrate: options.videoBitrate ?? '4M',
+            audioBitrate: options.audioBitrate ?? '192k',
+            outputFormat: options.outputFormat ?? 'mp4',
+            outputPath,
+            audioPath: options.audioPath ?? null,
+            preset: options.preset ?? 'fast',
+            crf: options.crf ?? 23,
+            subtitlePath: options.subtitlePath ?? null,
+        };
+        this.outputPath = outputPath;
+    }
+    /**
+     * Start the FFmpeg encoding process.
+     */
+    async start() {
+        if (this.ffmpeg) {
+            throw new Error('VideoEncoder: Already started');
+        }
+        this.startTime = Date.now();
+        // Check if NVENC is available for GPU-accelerated encoding
+        this.useNvenc = await checkNvencAvailable();
+        // Check if libass is available for subtitle burn-in
+        if (this.options.subtitlePath) {
+            const hasLibass = await checkLibassAvailable();
+            if (!hasLibass) {
+                console.warn('[VideoEncoder] Skipping ASS subtitle burn-in (libass not available)');
+                this.options.subtitlePath = null;
+            }
+        }
+        // Build FFmpeg arguments
+        const args = this.buildFFmpegArgs();
+        const encoder = this.useNvenc ? 'NVENC (GPU)' : 'libx264 (CPU)';
+        console.log(`[VideoEncoder] Starting FFmpeg with ${encoder}:`, args.join(' '));
+        this.ffmpeg = spawn('ffmpeg', args);
+        // Collect stderr for debugging
+        this.ffmpeg.stderr.on('data', (data) => {
+            this.stderrOutput += data.toString();
+        });
+        // Handle process errors
+        this.ffmpeg.on('error', (error) => {
+            captureServerError('[VideoEncoder] FFmpeg process error', error);
+        });
+        // Create a promise that resolves when FFmpeg exits (for EPIPE handling)
+        this.ffmpegExitPromise = new Promise((resolve) => {
+            this.ffmpeg.on('close', (code, signal) => {
+                if (code !== 0 && !this.isFinalized) {
+                    console.error(`[VideoEncoder] FFmpeg exited unexpectedly: code=${code}, signal=${signal}`);
+                    console.error(`[VideoEncoder] FFmpeg stderr:\n${this.stderrOutput}`);
+                }
+                resolve({ code, signal });
+            });
+        });
+        // Wait for FFmpeg to be ready (it starts accepting input immediately)
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.ffmpeg?.off('error', onError);
+                reject(new Error('VideoEncoder: FFmpeg startup timeout'));
+            }, 5000);
+            // FFmpeg is ready when it outputs to stderr (version info, etc.)
+            const onData = () => {
+                clearTimeout(timeout);
+                this.ffmpeg?.stderr.off('data', onData);
+                this.ffmpeg?.off('error', onError);
+                resolve();
+            };
+            const onError = (err) => {
+                clearTimeout(timeout);
+                this.ffmpeg?.stderr.off('data', onData);
+                reject(err);
+            };
+            this.ffmpeg.stderr.once('data', onData);
+            this.ffmpeg.once('error', onError);
+        });
+    }
+    /**
+     * Build FFmpeg command arguments.
+     */
+    buildFFmpegArgs() {
+        const { width, height, fps, videoBitrate, audioBitrate, preset, crf, audioPath, subtitlePath, } = this.options;
+        const args = [
+            // Overwrite output
+            '-y',
+            // Input: raw RGBA video from stdin
+            '-f',
+            'rawvideo',
+            '-pix_fmt',
+            'rgba',
+            '-s',
+            `${width}x${height}`,
+            '-r',
+            fps.toString(),
+            '-i',
+            'pipe:0',
+        ];
+        // Add audio input if provided
+        if (audioPath) {
+            args.push('-i', audioPath);
+        }
+        // Add subtitle filter if provided (burns ASS subtitles into the video)
+        if (subtitlePath) {
+            // Escape special characters in the path for FFmpeg filter syntax
+            // Do NOT wrap in single quotes — FFmpeg 8.x treats them as filter graph delimiters
+            const escapedPath = subtitlePath
+                .replace(/\\/g, '\\\\')
+                .replace(/:/g, '\\:')
+                .replace(/'/g, "\\'")
+                .replace(/\[/g, '\\[')
+                .replace(/]/g, '\\]')
+                .replace(/;/g, '\\;');
+            args.push('-vf', `ass=${escapedPath}`);
+        }
+        // Video encoding settings
+        args.push(
+        // Convert RGBA to YUV for H.264
+        '-pix_fmt', 'yuv420p');
+        if (this.useNvenc) {
+            // NVIDIA GPU hardware encoding (h264_nvenc)
+            // Map libx264 presets to NVENC presets: p1 (fastest) to p7 (slowest)
+            const nvencPresetMap = {
+                ultrafast: 'p1',
+                superfast: 'p2',
+                veryfast: 'p3',
+                faster: 'p4',
+                fast: 'p5',
+                medium: 'p6',
+            };
+            args.push('-c:v', 'h264_nvenc', 
+            // NVENC preset (p1-p7)
+            '-preset', nvencPresetMap[preset] ?? 'p5', 
+            // Constant quality mode (similar to CRF)
+            '-rc', 'constqp', '-qp', crf.toString(), 
+            // Bitrate (as max bitrate for constqp)
+            '-maxrate', videoBitrate, '-bufsize', videoBitrate, 
+            // Keyframe interval
+            '-g', fps.toString(), 
+            // Disable B-frames
+            '-bf', '0');
+        }
+        else {
+            // CPU software encoding (libx264)
+            args.push('-c:v', 'libx264', 
+            // H.264 High profile for broad compatibility (TikTok, Instagram, etc.)
+            '-profile:v', 'high', '-level', '4.2', 
+            // Encoding preset
+            '-preset', preset, 
+            // Constant Rate Factor (quality-based encoding, no bitrate target)
+            '-crf', crf.toString(), 
+            // Keyframe interval (1 second for better seeking)
+            '-g', fps.toString(), 
+            // Disable B-frames for better seeking accuracy
+            '-bf', '0');
+        }
+        // Audio encoding settings (if audio provided)
+        if (audioPath) {
+            args.push('-c:a', 'aac', '-b:a', audioBitrate);
+        }
+        // Output format settings for MP4
+        args.push(
+        // Enable fast start (moov atom at beginning for streaming)
+        '-movflags', '+faststart', 
+        // Output file
+        this.outputPath);
+        return args;
+    }
+    /**
+     * Write a frame to the encoder.
+     *
+     * @param rgba - Raw RGBA pixel data (Uint8Array from captureFrameResult)
+     * @returns Promise that resolves when frame is written (handles backpressure)
+     */
+    async writeFrame(rgba) {
+        if (!this.ffmpeg) {
+            throw new Error('VideoEncoder: Not started. Call start() first.');
+        }
+        if (this.isFinalized) {
+            throw new Error('VideoEncoder: Already finalized');
+        }
+        // Verify frame size
+        const expectedSize = this.options.width * this.options.height * 4;
+        if (rgba.length !== expectedSize) {
+            throw new Error(`VideoEncoder: Frame size mismatch. Expected ${expectedSize} bytes, got ${rgba.length}`);
+        }
+        // Write to FFmpeg stdin with EPIPE handling
+        // Use Buffer.copyBytesFrom to create a Node Buffer backed by the same memory
+        // when possible, avoiding a full copy of ~8MB per frame at 1080p
+        try {
+            const buf = rgba.buffer instanceof SharedArrayBuffer
+                ? Buffer.from(rgba)
+                : Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength);
+            const canContinue = this.ffmpeg.stdin.write(buf);
+            // Handle backpressure - wait for drain if buffer is full
+            if (!canContinue) {
+                await new Promise((resolve, reject) => {
+                    const onDrain = () => {
+                        this.ffmpeg.stdin.off('error', onError);
+                        resolve();
+                    };
+                    const onError = (err) => {
+                        this.ffmpeg.stdin.off('drain', onDrain);
+                        reject(err);
+                    };
+                    this.ffmpeg.stdin.once('drain', onDrain);
+                    this.ffmpeg.stdin.once('error', onError);
+                });
+            }
+        }
+        catch (error) {
+            // On EPIPE, wait for FFmpeg to exit to capture the real error
+            if (error instanceof Error &&
+                error.code === 'EPIPE') {
+                // Wait for FFmpeg to exit (with timeout)
+                if (this.ffmpegExitPromise) {
+                    const timeout = new Promise((resolve) => setTimeout(() => resolve({ code: null, signal: 'timeout' }), 2000));
+                    const exitInfo = await Promise.race([
+                        this.ffmpegExitPromise,
+                        timeout,
+                    ]);
+                    throw new Error(`FFmpeg crashed at frame ${this.framesWritten}: code=${exitInfo.code}, signal=${exitInfo.signal}\n` +
+                        `FFmpeg stderr:\n${this.stderrOutput}`);
+                }
+            }
+            throw error;
+        }
+        this.framesWritten++;
+    }
+    /**
+     * Finalize encoding and return the output.
+     */
+    async finalize() {
+        if (!this.ffmpeg) {
+            throw new Error('VideoEncoder: Not started');
+        }
+        if (this.isFinalized) {
+            throw new Error('VideoEncoder: Already finalized');
+        }
+        this.isFinalized = true;
+        // Close stdin to signal end of input
+        this.ffmpeg.stdin.end();
+        // Wait for FFmpeg to finish
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.ffmpeg?.kill('SIGKILL');
+                reject(new Error('VideoEncoder: FFmpeg finalization timeout'));
+            }, 60000); // 1 minute timeout
+            this.ffmpeg.on('close', (code) => {
+                clearTimeout(timeout);
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`VideoEncoder: FFmpeg exited with code ${code}\n${this.stderrOutput}`));
+                }
+            });
+        });
+        // Read the output file
+        const buffer = await fs.promises.readFile(this.outputPath);
+        const durationMs = Date.now() - this.startTime;
+        const stats = {
+            framesWritten: this.framesWritten,
+            bytesWritten: buffer.length,
+            durationMs,
+        };
+        const encoderUsed = this.useNvenc ? 'NVENC' : 'libx264';
+        console.log(`[VideoEncoder] Finalized (${encoderUsed}): ${this.framesWritten} frames, ${(buffer.length / 1024 / 1024).toFixed(2)} MB, ${(durationMs / 1000).toFixed(1)}s`);
+        return {
+            buffer,
+            path: this.outputPath,
+            stats,
+        };
+    }
+    /**
+     * Abort encoding and clean up.
+     */
+    abort() {
+        if (this.ffmpeg) {
+            this.ffmpeg.kill('SIGKILL');
+            this.ffmpeg = null;
+        }
+        // Clean up temp file
+        if (this.outputPath && fs.existsSync(this.outputPath)) {
+            fs.unlinkSync(this.outputPath);
+        }
+        this.isFinalized = true;
+    }
+    /**
+     * Get encoding statistics.
+     */
+    getStats() {
+        return {
+            framesWritten: this.framesWritten,
+            bytesWritten: 0, // Unknown until finalized
+            durationMs: Date.now() - this.startTime,
+        };
+    }
+    /**
+     * Clean up the output file (call after uploading to storage).
+     */
+    cleanup() {
+        if (this.outputPath && fs.existsSync(this.outputPath)) {
+            fs.unlinkSync(this.outputPath);
+        }
+    }
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Check if FFmpeg is available on the system.
+ */
+export async function checkFFmpegAvailable() {
+    return new Promise((resolve) => {
+        const ffmpeg = spawn('ffmpeg', ['-version']);
+        ffmpeg.on('close', (code) => {
+            resolve(code === 0);
+        });
+        ffmpeg.on('error', () => {
+            resolve(false);
+        });
+    });
+}
+/**
+ * Get FFmpeg version string.
+ */
+export async function getFFmpegVersion() {
+    return new Promise((resolve) => {
+        const ffmpeg = spawn('ffmpeg', ['-version']);
+        let output = '';
+        ffmpeg.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        ffmpeg.on('close', (code) => {
+            if (code === 0) {
+                // Extract version from first line
+                const match = /ffmpeg version (\S+)/.exec(output);
+                const firstLine = output.split('\n')[0];
+                resolve(match?.[1] ?? firstLine ?? null);
+            }
+            else {
+                resolve(null);
+            }
+        });
+        ffmpeg.on('error', () => {
+            resolve(null);
+        });
+    });
+}
+//# sourceMappingURL=VideoEncoder.js.map