rollberry 0.1.8 → 0.2.0

package/dist/capture/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const AUTO_DURATION_MIN_SECONDS = 4;
+export declare const AUTO_DURATION_MAX_SECONDS = 40;
+export declare const AUTO_DURATION_PIXELS_PER_SECOND = 800;
+export declare const TIMELINE_AUTO_DURATION_MIN_SECONDS = 0.6;
+export declare const TIMELINE_AUTO_DURATION_MAX_SECONDS = 12;
+export declare const TIMELINE_AUTO_DURATION_PIXELS_PER_SECOND = 1400;
+export declare const LOCALHOST_RETRY_INTERVAL_MS = 500;
+export declare const STABILIZE_DELAY_MS = 500;
+export declare const PREFLIGHT_STEP_DELAY_MS = 120;
+export declare const PREFLIGHT_STABLE_ROUNDS = 3;
+export declare const PREFLIGHT_MAX_SCROLL_HEIGHT = 30000;
+export declare const MAX_TOTAL_FRAMES = 36000;
+export declare const MAX_FPS = 120;
+export declare const FONT_LOADING_TIMEOUT_MS = 10000;
+export declare const MAX_PREFLIGHT_ITERATIONS = 20;

package/dist/capture/constants.js

@@ -1,8 +1,15 @@
 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;
 export const PREFLIGHT_STABLE_ROUNDS = 3;
 export const PREFLIGHT_MAX_SCROLL_HEIGHT = 30_000;
+export const MAX_TOTAL_FRAMES = 36_000;
+export const MAX_FPS = 120;
+export const FONT_LOADING_TIMEOUT_MS = 10_000;
+export const MAX_PREFLIGHT_ITERATIONS = 20;

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,38 +1,31 @@
-import { spawn } from 'node:child_process';
-import { once } from 'node:events';
+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) => {
+            if (error) {
+                reject(createFfmpegPreflightError(error));
+                return;
+            }
+            resolve();
+        });
+    });
+}
 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;
     let stderr = '';
+    let closeResult;
+    const closePromise = new Promise((resolve) => {
+        ffmpeg.once('close', (exitCode, signal) => {
+            closeResult = { exitCode, signal };
+            resolve(closeResult);
+        });
+    });
     ffmpeg.on('error', (error) => {
         spawnError = error;
     });
@@ -45,9 +38,12 @@ export async function createVideoEncoder(options) {
             if (spawnError) {
                 throw createEncoderError(spawnError, stderr);
             }
+            if (closeResult) {
+                throw createEncoderError(new Error(`FFmpeg exited before encoding completed (${formatCloseResult(closeResult)})`), stderr);
+            }
             const stdin = ffmpeg.stdin;
             if (stdin.destroyed) {
-                throw createEncoderError(new Error('FFmpeg の標準入力が閉じています。'), stderr);
+                throw createEncoderError(new Error('FFmpeg stdin is closed.'), stderr);
             }
             await new Promise((resolve, reject) => {
                 stdin.write(frame, (error) => {
@@ -63,18 +59,443 @@ export async function createVideoEncoder(options) {
             if (spawnError) {
                 throw createEncoderError(spawnError, stderr);
             }
-            ffmpeg.stdin.end();
-            const [exitCode] = (await once(ffmpeg, 'close'));
-            if (exitCode !== 0) {
-                throw createEncoderError(new Error(`FFmpeg が異常終了しました (exit code: ${exitCode ?? 'null'})`), stderr);
+            if (!ffmpeg.stdin.destroyed && !ffmpeg.stdin.writableEnded) {
+                ffmpeg.stdin.end();
+            }
+            const result = closeResult ?? (await closePromise);
+            if (result.exitCode !== 0) {
+                throw createEncoderError(new Error(`FFmpeg exited with error (${formatCloseResult(result)})`), stderr);
+            }
+        },
+        async abort() {
+            try {
+                if (!ffmpeg.stdin.destroyed && !ffmpeg.stdin.writableEnded) {
+                    ffmpeg.stdin.destroy();
+                }
+            }
+            catch {
+                // stdin may already be closed
+            }
+            if (closeResult) {
+                await closePromise;
+                return;
+            }
+            try {
+                ffmpeg.kill('SIGTERM');
+            }
+            catch {
+                // Process may already be exiting
+            }
+            const exited = await Promise.race([
+                closePromise.then(() => true),
+                new Promise((resolve) => {
+                    setTimeout(resolve, FFMPEG_ABORT_TIMEOUT_MS, false);
+                }),
+            ]);
+            if (!exited && !closeResult) {
+                try {
+                    ffmpeg.kill('SIGKILL');
+                }
+                catch {
+                    // Process may already be exiting
+                }
+                await closePromise;
             }
         },
     };
 }
+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([
+            'FFmpeg is required but was not found in PATH.',
+            '  macOS:   brew install ffmpeg',
+            '  Ubuntu:  sudo apt install ffmpeg',
+            '  Windows: winget install ffmpeg',
+        ].join('\n'));
+    }
+    return new Error(`Failed to execute FFmpeg: ${error.message}`);
+}
 function createEncoderError(error, stderr) {
     if ('code' in error && error.code === 'ENOENT') {
-        return new Error('FFmpeg が見つかりません。PATH に ffmpeg を追加してください。');
+        return new Error('FFmpeg not found. Please add ffmpeg to your PATH.');
     }
     const detail = stderr.trim();
     return new Error(detail ? `${error.message}\n${detail}` : error.message);
 }
+function formatCloseResult(result) {
+    if (result.signal) {
+        return `signal: ${result.signal}`;
+    }
+    return `exit code: ${result.exitCode ?? 'null'}`;
+}

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/preflight.js

@@ -1,10 +1,16 @@
-import { PREFLIGHT_MAX_SCROLL_HEIGHT, PREFLIGHT_STABLE_ROUNDS, PREFLIGHT_STEP_DELAY_MS, } from './constants.js';
+import { MAX_PREFLIGHT_ITERATIONS, PREFLIGHT_MAX_SCROLL_HEIGHT, PREFLIGHT_STABLE_ROUNDS, PREFLIGHT_STEP_DELAY_MS, } from './constants.js';
 import { delay, measurePage, waitForAnimationFrames } from './utils.js';
-export async function preflightMeasurePage(page) {
+export async function preflightMeasurePage(page, logger) {
     let metrics = await measurePage(page);
     let truncated = metrics.scrollHeight > PREFLIGHT_MAX_SCROLL_HEIGHT;
     let stableRounds = metrics.maxScroll === 0 ? PREFLIGHT_STABLE_ROUNDS : 0;
+    let iterations = 0;
     while (!truncated && stableRounds < PREFLIGHT_STABLE_ROUNDS) {
+        iterations += 1;
+        if (iterations > MAX_PREFLIGHT_ITERATIONS) {
+            await logger?.warn('preflight.max_iterations', `Preflight measurement stopped after ${MAX_PREFLIGHT_ITERATIONS} iterations (page content may still be loading)`);
+            break;
+        }
         let position = 0;
         while (position < metrics.maxScroll) {
             position = Math.min(position + metrics.viewportHeight, metrics.maxScroll);

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;