rollberry 0.1.9 → 0.2.0

package/dist/capture/constants.js

@@ -1,6 +1,9 @@
 export const AUTO_DURATION_MIN_SECONDS = 4;
 export const AUTO_DURATION_MAX_SECONDS = 40;
 export const AUTO_DURATION_PIXELS_PER_SECOND = 800;
+export const TIMELINE_AUTO_DURATION_MIN_SECONDS = 0.6;
+export const TIMELINE_AUTO_DURATION_MAX_SECONDS = 12;
+export const TIMELINE_AUTO_DURATION_PIXELS_PER_SECOND = 1_400;
 export const LOCALHOST_RETRY_INTERVAL_MS = 500;
 export const STABILIZE_DELAY_MS = 500;
 export const PREFLIGHT_STEP_DELAY_MS = 120;

package/dist/capture/ffmpeg.d.ts

@@ -0,0 +1,41 @@
+import type { CaptureAudioTrack, CaptureSubtitleTrack, CaptureTransition, CaptureVideoEncodingSettings, FinalVideoEncodingSettings, OutputFormat } from './types.js';
+export interface VideoEncoder {
+    writeFrame(frame: Buffer): Promise<void>;
+    finish(): Promise<void>;
+    abort(): Promise<void>;
+}
+export interface ComposedVideoClip {
+    path: string;
+    durationSeconds: number;
+}
+export interface VideoProbeResult {
+    durationSeconds: number;
+    frameCount?: number;
+}
+export interface VideoProbeOutcome {
+    status: 'probed' | 'unavailable' | 'failed' | 'invalid';
+    result?: VideoProbeResult;
+    warning?: string;
+}
+export declare function checkFfmpegAvailable(): Promise<void>;
+export declare function createVideoEncoder(options: {
+    fps: number;
+    outPath: string;
+    format: OutputFormat;
+    audio?: CaptureAudioTrack;
+    subtitles?: CaptureSubtitleTrack;
+    transition?: CaptureTransition;
+    videoEncoding?: CaptureVideoEncodingSettings;
+}): Promise<VideoEncoder>;
+export declare function composeVideoClips(options: {
+    clips: [ComposedVideoClip, ...ComposedVideoClip[]];
+    outPath: string;
+    format: OutputFormat;
+    fps: number;
+    audio?: CaptureAudioTrack;
+    subtitles?: CaptureSubtitleTrack;
+    transition?: CaptureTransition;
+    finalVideo: FinalVideoEncodingSettings;
+    force: boolean;
+}): Promise<void>;
+export declare function probeVideoFile(filePath: string): Promise<VideoProbeOutcome>;

package/dist/capture/ffmpeg.js

@@ -1,5 +1,7 @@
 import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
 const FFMPEG_ABORT_TIMEOUT_MS = 1_000;
+const execFileAsync = promisify(execFile);
 export async function checkFfmpegAvailable() {
     await new Promise((resolve, reject) => {
         execFile('ffmpeg', ['-version'], (error) => {
@@ -12,34 +14,7 @@ export async function checkFfmpegAvailable() {
     });
 }
 export async function createVideoEncoder(options) {
-    const ffmpeg = spawn('ffmpeg', [
-        '-hide_banner',
-        '-loglevel',
-        'error',
-        '-y',
-        '-f',
-        'image2pipe',
-        '-framerate',
-        String(options.fps),
-        '-c:v',
-        'png',
-        '-i',
-        'pipe:0',
-        '-an',
-        '-c:v',
-        'libx264',
-        '-pix_fmt',
-        'yuv420p',
-        '-preset',
-        'slow',
-        '-crf',
-        '18',
-        '-movflags',
-        '+faststart',
-        '-vf',
-        'pad=ceil(iw/2)*2:ceil(ih/2)*2',
-        options.outPath,
-    ], {
+    const ffmpeg = spawn('ffmpeg', buildStreamingFfmpegArgs(options), {
         stdio: ['pipe', 'ignore', 'pipe'],
     });
     let spawnError;
@@ -129,6 +104,377 @@ export async function createVideoEncoder(options) {
         },
     };
 }
+export async function composeVideoClips(options) {
+    await runFfmpeg(buildComposeFfmpegArgs(options));
+}
+export async function probeVideoFile(filePath) {
+    try {
+        const { stdout } = await execFileAsync('ffprobe', [
+            '-v',
+            'error',
+            '-count_frames',
+            '-print_format',
+            'json',
+            '-show_format',
+            '-show_streams',
+            filePath,
+        ]);
+        const parsed = JSON.parse(formatExecBuffer(stdout));
+        const videoStream = parsed.streams?.find((stream) => stream.codec_type === 'video');
+        const durationSeconds = parseFiniteNumber(parsed.format?.duration ?? videoStream?.duration);
+        if (durationSeconds === undefined) {
+            return {
+                status: 'invalid',
+                warning: `ffprobe did not return a usable duration for: ${filePath}`,
+            };
+        }
+        return {
+            status: 'probed',
+            result: {
+                durationSeconds,
+                frameCount: parseFrameCount(videoStream?.nb_read_frames ?? videoStream?.nb_frames),
+            },
+        };
+    }
+    catch (error) {
+        if (error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return {
+                status: 'unavailable',
+                warning: 'ffprobe is not available on PATH; falling back to estimated metrics.',
+            };
+        }
+        return {
+            status: 'failed',
+            warning: error instanceof Error
+                ? `ffprobe failed for ${filePath}: ${error.message}`
+                : `ffprobe failed for ${filePath}.`,
+        };
+    }
+}
+function buildStreamingFfmpegArgs(options) {
+    const args = [
+        '-hide_banner',
+        '-loglevel',
+        'error',
+        '-y',
+        '-f',
+        'image2pipe',
+        '-framerate',
+        String(options.fps),
+        '-c:v',
+        'png',
+        '-i',
+        'pipe:0',
+    ];
+    let nextInputIndex = 1;
+    let audioInputIndex;
+    let subtitleInputIndex;
+    if (options.audio) {
+        if (options.audio.loop) {
+            args.push('-stream_loop', '-1');
+        }
+        args.push('-i', options.audio.sourcePath);
+        audioInputIndex = nextInputIndex;
+        nextInputIndex += 1;
+    }
+    if (options.subtitles?.mode === 'soft') {
+        args.push('-i', options.subtitles.sourcePath);
+        subtitleInputIndex = nextInputIndex;
+        nextInputIndex += 1;
+    }
+    args.push('-map', '0:v:0');
+    if (audioInputIndex !== undefined) {
+        args.push('-map', `${audioInputIndex}:a:0`);
+    }
+    if (subtitleInputIndex !== undefined) {
+        args.push('-map', `${subtitleInputIndex}:s:0`);
+    }
+    if (options.audio) {
+        args.push('-af', buildAudioFilter(options.audio));
+        args.push('-shortest');
+    }
+    else {
+        args.push('-an');
+    }
+    args.push('-vf', buildVideoFilter(options.subtitles, options.transition));
+    args.push(...buildIntermediateFormatArgs(options.format, options.audio, options.subtitles, options.videoEncoding));
+    args.push(options.outPath);
+    return args;
+}
+function buildComposeFfmpegArgs(options) {
+    const args = [
+        '-hide_banner',
+        '-loglevel',
+        'error',
+        options.force ? '-y' : '-n',
+    ];
+    for (const clip of options.clips) {
+        args.push('-i', clip.path);
+    }
+    let nextInputIndex = options.clips.length;
+    let audioInputIndex;
+    let subtitleInputIndex;
+    if (options.audio) {
+        if (options.audio.loop) {
+            args.push('-stream_loop', '-1');
+        }
+        args.push('-i', options.audio.sourcePath);
+        audioInputIndex = nextInputIndex;
+        nextInputIndex += 1;
+    }
+    if (options.subtitles?.mode === 'soft') {
+        args.push('-i', options.subtitles.sourcePath);
+        subtitleInputIndex = nextInputIndex;
+    }
+    const filterComplex = buildComposeFilterComplex({
+        clips: options.clips,
+        subtitles: options.subtitles,
+        transition: options.transition,
+    });
+    if (filterComplex) {
+        args.push('-filter_complex', filterComplex, '-map', '[video_out]');
+    }
+    else {
+        args.push('-map', '0:v:0');
+    }
+    if (audioInputIndex !== undefined) {
+        const audio = options.audio;
+        if (!audio) {
+            throw new Error('Audio input index was set without an audio track.');
+        }
+        args.push('-map', `${audioInputIndex}:a:0`);
+        args.push('-af', buildAudioFilter(audio));
+        args.push('-shortest');
+    }
+    else {
+        args.push('-an');
+    }
+    if (subtitleInputIndex !== undefined) {
+        args.push('-map', `${subtitleInputIndex}:s:0`);
+    }
+    args.push('-r', String(options.fps));
+    args.push(...buildFinalFormatArgs(options.format, options.audio, options.subtitles, options.finalVideo));
+    args.push(options.outPath);
+    return args;
+}
+function buildComposeFilterComplex(options) {
+    const segments = [];
+    const crossfade = options.transition?.kind === 'crossfade' && options.clips.length > 1
+        ? options.transition
+        : undefined;
+    let currentLabel;
+    if (crossfade) {
+        validateCrossfadeDuration(options.clips, crossfade.durationSeconds);
+        for (const [index] of options.clips.entries()) {
+            segments.push(`[${index}:v:0]format=yuv420p,setsar=1[v${index}]`);
+        }
+        currentLabel = '[v0]';
+        let accumulatedDuration = options.clips[0].durationSeconds;
+        for (let index = 1; index < options.clips.length; index += 1) {
+            const outputLabel = `[xfade${index}]`;
+            const offset = accumulatedDuration - crossfade.durationSeconds * index;
+            segments.push(`${currentLabel}[v${index}]xfade=transition=fade:duration=${formatFilterNumber(crossfade.durationSeconds)}:offset=${formatFilterNumber(offset)}${outputLabel}`);
+            currentLabel = outputLabel;
+            accumulatedDuration += options.clips[index].durationSeconds;
+        }
+    }
+    else if (options.clips.length > 1) {
+        currentLabel = '[concat_video]';
+        segments.push(`${options.clips
+            .map((_, index) => `[${index}:v:0]`)
+            .join('')}concat=n=${options.clips.length}:v=1:a=0${currentLabel}`);
+    }
+    else {
+        currentLabel = '[0:v:0]';
+    }
+    const postFilters = ['pad=ceil(iw/2)*2:ceil(ih/2)*2'];
+    if (options.subtitles?.mode === 'burn-in') {
+        postFilters.push(buildBurnInSubtitleFilter(options.subtitles));
+    }
+    if (options.transition?.kind === 'fade-in') {
+        postFilters.push(`fade=t=in:st=0:d=${formatFilterNumber(options.transition.durationSeconds)}`);
+    }
+    if (postFilters.length === 0) {
+        return segments.length > 0 ? segments.join(';') : undefined;
+    }
+    segments.push(`${currentLabel}${postFilters.join(',')}[video_out]`);
+    return segments.join(';');
+}
+function buildVideoFilter(subtitles, transition) {
+    const filters = ['pad=ceil(iw/2)*2:ceil(ih/2)*2'];
+    if (subtitles?.mode === 'burn-in') {
+        filters.push(buildBurnInSubtitleFilter(subtitles));
+    }
+    if (transition?.kind === 'fade-in') {
+        filters.push(`fade=t=in:st=0:d=${formatFilterNumber(transition.durationSeconds)}`);
+    }
+    return filters.join(',');
+}
+function buildBurnInSubtitleFilter(subtitles) {
+    return `subtitles=filename='${escapeFfmpegFilterString(subtitles.sourcePath)}'`;
+}
+function buildAudioFilter(audio) {
+    return `volume=${audio.volume.toFixed(3)},apad`;
+}
+function buildIntermediateFormatArgs(format, audio, subtitles, videoEncoding) {
+    switch (format) {
+        case 'mp4': {
+            const args = [
+                '-c:v',
+                'libx264',
+                '-pix_fmt',
+                'yuv420p',
+                '-preset',
+                videoEncoding?.preset ?? 'slow',
+                '-crf',
+                String(videoEncoding?.crf ?? 18),
+                '-movflags',
+                '+faststart',
+            ];
+            if (audio) {
+                args.push('-c:a', 'aac', '-b:a', '192k');
+            }
+            if (subtitles?.mode === 'soft') {
+                args.push('-c:s', 'mov_text');
+            }
+            return args;
+        }
+        case 'webm': {
+            const args = [
+                '-c:v',
+                'libvpx-vp9',
+                '-pix_fmt',
+                'yuv420p',
+                '-row-mt',
+                '1',
+                '-deadline',
+                'good',
+                '-crf',
+                '32',
+                '-b:v',
+                '0',
+            ];
+            if (audio) {
+                args.push('-c:a', 'libopus', '-b:a', '128k');
+            }
+            if (subtitles?.mode === 'soft') {
+                args.push('-c:s', 'webvtt');
+            }
+            return args;
+        }
+    }
+}
+function buildFinalFormatArgs(format, audio, subtitles, videoEncoding) {
+    switch (format) {
+        case 'mp4': {
+            if (videoEncoding.format !== 'mp4') {
+                throw new Error('Final video settings do not match mp4 output format.');
+            }
+            const args = [
+                '-c:v',
+                'libx264',
+                '-pix_fmt',
+                'yuv420p',
+                '-preset',
+                videoEncoding.preset,
+                '-crf',
+                String(videoEncoding.crf),
+                '-movflags',
+                '+faststart',
+            ];
+            if (audio) {
+                args.push('-c:a', 'aac', '-b:a', '192k');
+            }
+            if (subtitles?.mode === 'soft') {
+                args.push('-c:s', 'mov_text');
+            }
+            return args;
+        }
+        case 'webm': {
+            if (videoEncoding.format !== 'webm') {
+                throw new Error('Final video settings do not match webm output format.');
+            }
+            const args = [
+                '-c:v',
+                'libvpx-vp9',
+                '-pix_fmt',
+                'yuv420p',
+                '-row-mt',
+                '1',
+                '-deadline',
+                videoEncoding.deadline,
+                '-crf',
+                String(videoEncoding.crf),
+                '-b:v',
+                '0',
+            ];
+            if (audio) {
+                args.push('-c:a', 'libopus', '-b:a', '128k');
+            }
+            if (subtitles?.mode === 'soft') {
+                args.push('-c:s', 'webvtt');
+            }
+            return args;
+        }
+    }
+}
+async function runFfmpeg(args) {
+    try {
+        await execFileAsync('ffmpeg', args);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            const stderr = 'stderr' in error ? formatExecBuffer(error.stderr) : '';
+            throw createEncoderError(error, stderr);
+        }
+        throw error;
+    }
+}
+function validateCrossfadeDuration(clips, durationSeconds) {
+    for (let index = 0; index < clips.length - 1; index += 1) {
+        const left = clips[index];
+        const right = clips[index + 1];
+        const maxDuration = Math.min(left.durationSeconds, right.durationSeconds);
+        if (durationSeconds >= maxDuration) {
+            throw new Error(`Crossfade duration ${durationSeconds.toFixed(3)}s is too long for scene pair ${index + 1}-${index + 2}. Each adjacent scene must be longer than the crossfade.`);
+        }
+    }
+}
+function escapeFfmpegFilterString(value) {
+    return value
+        .replaceAll('\\', '\\\\')
+        .replaceAll(':', '\\:')
+        .replaceAll("'", "\\'");
+}
+function formatFilterNumber(value) {
+    return value.toFixed(3);
+}
+function formatExecBuffer(value) {
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (Buffer.isBuffer(value)) {
+        return value.toString('utf8').trim();
+    }
+    return '';
+}
+function parseFiniteNumber(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseFrameCount(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
 function createFfmpegPreflightError(error) {
     if (error.code === 'ENOENT') {
         return new Error([

package/dist/capture/logger.d.ts

@@ -0,0 +1,15 @@
+export type CaptureLogLevel = 'info' | 'warn' | 'error';
+export interface CaptureLogEvent {
+    timestamp: string;
+    level: CaptureLogLevel;
+    event: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+export interface CaptureLogger {
+    info(event: string, message: string, data?: Record<string, unknown>): Promise<void>;
+    warn(event: string, message: string, data?: Record<string, unknown>): Promise<void>;
+    error(event: string, message: string, data?: Record<string, unknown>): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createCaptureLogger(logFilePath: string): CaptureLogger;

package/dist/capture/preflight.d.ts

@@ -0,0 +1,4 @@
+import type { Page } from 'playwright';
+import type { CaptureLogger } from './logger.js';
+import type { PreflightResult } from './types.js';
+export declare function preflightMeasurePage(page: Page, logger?: CaptureLogger): Promise<PreflightResult>;

package/dist/capture/progress.d.ts

@@ -0,0 +1,7 @@
+export interface ProgressReporter {
+    onPageStart(pageIndex: number, totalPages: number, url: string): void;
+    onFrameRendered(frameIndex: number, totalFrames: number): void;
+    onPageComplete(pageIndex: number): void;
+    onEncodeComplete(): void;
+}
+export declare function createProgressReporter(): ProgressReporter;

package/dist/capture/scroll-plan.d.ts

@@ -0,0 +1,9 @@
+import type { MotionCurve } from './types.js';
+export declare function resolveDurationSeconds(requestedDuration: number | 'auto', maxScroll: number): number;
+export declare function buildScrollFrames(options: {
+    fps: number;
+    durationSeconds: number;
+    maxScroll: number;
+    motion: MotionCurve;
+}): number[];
+export declare function resolveTimelineDurationSeconds(distance: number): number;

package/dist/capture/scroll-plan.js

@@ -1,4 +1,4 @@
-import { AUTO_DURATION_MAX_SECONDS, AUTO_DURATION_MIN_SECONDS, AUTO_DURATION_PIXELS_PER_SECOND, MAX_TOTAL_FRAMES, } from './constants.js';
+import { AUTO_DURATION_MAX_SECONDS, AUTO_DURATION_MIN_SECONDS, AUTO_DURATION_PIXELS_PER_SECOND, MAX_TOTAL_FRAMES, TIMELINE_AUTO_DURATION_MAX_SECONDS, TIMELINE_AUTO_DURATION_MIN_SECONDS, TIMELINE_AUTO_DURATION_PIXELS_PER_SECOND, } from './constants.js';
 import { clamp } from './utils.js';
 export function resolveDurationSeconds(requestedDuration, maxScroll) {
     if (requestedDuration !== 'auto') {
@@ -20,6 +20,9 @@ export function buildScrollFrames(options) {
         return Number((options.maxScroll * easedProgress).toFixed(3));
     });
 }
+export function resolveTimelineDurationSeconds(distance) {
+    return clamp(distance / TIMELINE_AUTO_DURATION_PIXELS_PER_SECOND, TIMELINE_AUTO_DURATION_MIN_SECONDS, TIMELINE_AUTO_DURATION_MAX_SECONDS);
+}
 function easeInOutSine(value) {
     return -(Math.cos(Math.PI * value) - 1) / 2;
 }

package/dist/capture/stabilize.d.ts

@@ -0,0 +1,7 @@
+import type { Page } from 'playwright';
+import type { WaitForCondition } from './types.js';
+export declare function stabilizePage(options: {
+    page: Page;
+    waitFor: WaitForCondition;
+    hideSelectors: string[];
+}): Promise<void>;