rollberry 0.1.8 → 0.2.0

package/dist/capture/progress.js

@@ -0,0 +1,50 @@
+export function createProgressReporter() {
+    const isTTY = process.stderr.isTTY === true;
+    let lastUpdateTime = 0;
+    let lastReportedMilestone = -1;
+    function clearLine() {
+        if (isTTY) {
+            process.stderr.write('\r\x1b[K');
+        }
+    }
+    return {
+        onPageStart(pageIndex, totalPages, url) {
+            clearLine();
+            lastReportedMilestone = -1;
+            const displayUrl = url.length > 60 ? `${url.slice(0, 57)}...` : url;
+            process.stderr.write(`Capturing page ${pageIndex + 1}/${totalPages}: ${displayUrl}\n`);
+        },
+        onFrameRendered(frameIndex, totalFrames) {
+            const now = Date.now();
+            const isLast = frameIndex + 1 === totalFrames;
+            if (!isLast && now - lastUpdateTime < 100) {
+                return;
+            }
+            lastUpdateTime = now;
+            const progress = (frameIndex + 1) / totalFrames;
+            const percent = Math.round(progress * 100);
+            if (isTTY) {
+                const barWidth = 20;
+                const filled = Math.round(barWidth * progress);
+                const bar = '#'.repeat(filled) + '-'.repeat(barWidth - filled);
+                process.stderr.write(`\r  [${bar}] ${percent}% (${frameIndex + 1}/${totalFrames} frames)`);
+                if (isLast) {
+                    process.stderr.write('\n');
+                }
+            }
+            else {
+                const milestone = Math.floor(percent / 25) * 25;
+                if (isLast || (milestone > lastReportedMilestone && milestone > 0)) {
+                    lastReportedMilestone = milestone;
+                    process.stderr.write(`  Progress: ${percent}% (${frameIndex + 1}/${totalFrames} frames)\n`);
+                }
+            }
+        },
+        onPageComplete(_pageIndex) {
+            // Line already advanced after last frame render
+        },
+        onEncodeComplete() {
+            // Summary is printed by cli.ts
+        },
+    };
+}

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, } 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') {
@@ -8,6 +8,9 @@ export function resolveDurationSeconds(requestedDuration, maxScroll) {
 }
 export function buildScrollFrames(options) {
     const frameCount = Math.max(1, Math.ceil(options.durationSeconds * options.fps));
+    if (frameCount > MAX_TOTAL_FRAMES) {
+        throw new Error(`Frame count ${frameCount} exceeds maximum ${MAX_TOTAL_FRAMES}. Reduce --fps or --duration.`);
+    }
     if (frameCount === 1) {
         return [0];
     }
@@ -17,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>;

package/dist/capture/stabilize.js

@@ -1,5 +1,5 @@
-import { STABILIZE_DELAY_MS } from './constants.js';
-import { delay, waitForAnimationFrames } from './utils.js';
+import { FONT_LOADING_TIMEOUT_MS, STABILIZE_DELAY_MS } from './constants.js';
+import { delay, validateHideSelector, waitForAnimationFrames, } from './utils.js';
 export async function stabilizePage(options) {
     await options.page.addStyleTag({
         content: buildStabilizingCss(options.hideSelectors),
@@ -13,6 +13,9 @@ export async function stabilizePage(options) {
     await waitForAnimationFrames(options.page);
 }
 function buildStabilizingCss(hideSelectors) {
+    for (const selector of hideSelectors) {
+        validateHideSelector(selector);
+    }
     const hiddenSelectorBlock = hideSelectors.length > 0
         ? `${hideSelectors.join(', ')} { display: none !important; visibility: hidden !important; }\n`
         : '';
@@ -47,10 +50,13 @@ async function waitForRequestedCondition(page, waitFor) {
     await delay(waitFor.ms);
 }
 async function waitForFonts(page) {
-    await page.evaluate(async () => {
+    await page.evaluate(async (timeoutMs) => {
         if (!('fonts' in document)) {
             return;
         }
-        await document.fonts.ready;
-    });
+        await Promise.race([
+            document.fonts.ready,
+            new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+        ]);
+    }, FONT_LOADING_TIMEOUT_MS);
 }

package/dist/capture/types.d.ts

@@ -0,0 +1,216 @@
+export type MotionCurve = 'ease-in-out-sine' | 'linear';
+export type NonEmptyArray<T> = [T, ...T[]];
+export type ScrollAlignment = 'start' | 'center' | 'end';
+export type OutputFormat = 'mp4' | 'webm';
+export type SubtitleFormat = 'srt' | 'webvtt';
+export type SubtitleMode = 'soft' | 'burn-in';
+export type H264Preset = 'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium' | 'slow' | 'slower' | 'veryslow' | 'placebo';
+export type Vp9Deadline = 'best' | 'good' | 'realtime';
+export type WaitForCondition = {
+    kind: 'load';
+} | {
+    kind: 'selector';
+    selector: string;
+} | {
+    kind: 'delay';
+    ms: number;
+};
+export interface Viewport {
+    width: number;
+    height: number;
+}
+export interface CaptureOptions {
+    urls: NonEmptyArray<URL>;
+    outPath: string;
+    manifestPath: string;
+    logFilePath: string;
+    viewport: Viewport;
+    fps: number;
+    duration: number | 'auto';
+    motion: MotionCurve;
+    timeoutMs: number;
+    waitFor: WaitForCondition;
+    hideSelectors: string[];
+    pageGapSeconds: number;
+    debugFramesDir?: string;
+    force: boolean;
+}
+export type CaptureAction = {
+    kind: 'wait';
+    ms: number;
+} | {
+    kind: 'click';
+    selector: string;
+} | {
+    kind: 'hover';
+    selector: string;
+} | {
+    kind: 'press';
+    key: string;
+} | {
+    kind: 'type';
+    selector: string;
+    text: string;
+    clear: boolean;
+} | {
+    kind: 'scroll-to';
+    selector: string;
+    block: ScrollAlignment;
+};
+export type CaptureTimelineScrollTarget = {
+    kind: 'bottom';
+} | {
+    kind: 'absolute';
+    top: number;
+} | {
+    kind: 'relative';
+    delta: number;
+} | {
+    kind: 'selector';
+    selector: string;
+    block: ScrollAlignment;
+};
+export type CaptureTimelineSegment = {
+    kind: 'scroll';
+    duration: number | 'auto';
+    motion: MotionCurve;
+    target: CaptureTimelineScrollTarget;
+} | {
+    kind: 'pause';
+    durationSeconds: number;
+} | {
+    kind: 'action';
+    action: Exclude<CaptureAction, {
+        kind: 'wait';
+    }>;
+    holdAfterSeconds: number;
+};
+export interface CaptureScene {
+    name?: string;
+    url: URL;
+    duration: number | 'auto';
+    motion: MotionCurve;
+    waitFor: WaitForCondition;
+    hideSelectors: string[];
+    holdAfterSeconds: number;
+    actions: CaptureAction[];
+    timeline: CaptureTimelineSegment[];
+}
+export interface CaptureJob {
+    scenes: NonEmptyArray<CaptureScene>;
+    outPath: string;
+    format: OutputFormat;
+    viewport: Viewport;
+    fps: number;
+    timeoutMs: number;
+    audio?: CaptureAudioTrack;
+    subtitles?: CaptureSubtitleTrack;
+    transition?: CaptureTransition;
+    videoEncoding?: CaptureVideoEncodingSettings;
+    debugFramesDir?: string;
+    includeHoldAfterFinalScene?: boolean;
+    force: boolean;
+}
+export interface CaptureVideoEncodingSettings {
+    preset: H264Preset;
+    crf: number;
+}
+export interface IntermediateArtifactProfile {
+    format: 'mp4';
+    extension: '.mp4';
+    videoEncoding: CaptureVideoEncodingSettings;
+}
+export interface CaptureAudioTrack {
+    sourcePath: string;
+    volume: number;
+    loop: boolean;
+}
+export interface CaptureSubtitleTrack {
+    sourcePath: string;
+    format: SubtitleFormat;
+    mode: SubtitleMode;
+}
+export type CaptureTransition = {
+    kind: 'fade-in';
+    durationSeconds: number;
+} | {
+    kind: 'crossfade';
+    durationSeconds: number;
+};
+export type FinalVideoEncodingSettings = {
+    format: 'mp4';
+    preset: H264Preset;
+    crf: number;
+} | {
+    format: 'webm';
+    deadline: Vp9Deadline;
+    crf: number;
+};
+export interface ResolvedCaptureOptions extends CaptureOptions {
+    durationSeconds: number;
+}
+export interface PageMetrics {
+    scrollHeight: number;
+    viewportHeight: number;
+    maxScroll: number;
+}
+export interface PreflightResult extends PageMetrics {
+    truncated: boolean;
+}
+export interface PageCaptureResult {
+    name?: string;
+    url: string;
+    frameCount: number;
+    durationSeconds: number;
+    scrollHeight: number;
+    truncated: boolean;
+}
+export interface CaptureResult {
+    outPath: string;
+    frameCount: number;
+    durationSeconds: number;
+    pages: PageCaptureResult[];
+    truncated: boolean;
+}
+export interface CaptureRunResult {
+    capture: CaptureResult;
+    manifestPath: string;
+    logFilePath: string;
+}
+export interface CaptureManifest {
+    schemaVersion: 2;
+    status: 'succeeded' | 'failed' | 'cancelled';
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    environment: {
+        nodeVersion: string;
+        platform: NodeJS.Platform;
+        arch: string;
+    };
+    options: {
+        urls: string[];
+        viewport: Viewport;
+        fps: number;
+        duration: number | 'auto';
+        motion: MotionCurve;
+        timeoutMs: number;
+        waitFor: WaitForCondition;
+        hideSelectors: string[];
+        pageGapSeconds: number;
+    };
+    artifacts: {
+        videoPath: string;
+        manifestPath: string;
+        logFilePath: string;
+        debugFramesDir?: string;
+        videoCreated: boolean;
+    };
+    result?: CaptureResult;
+    warnings: string[];
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}

package/dist/capture/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Page } from 'playwright';
+import type { PageMetrics } from './types.js';
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function isLocalUrl(url: URL): boolean;
+export declare function parseCaptureUrl(rawUrl: string): URL;
+export declare function sanitizeUrl(url: URL): string;
+export declare function formatFileSize(bytes: number): string;
+export declare function validateHideSelector(selector: string): void;
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function ensureParentDirectory(filePath: string): Promise<void>;
+export declare function ensureDirectory(path: string): Promise<void>;
+export declare function delay(ms: number): Promise<void>;
+export declare function waitForAnimationFrames(page: Page, frameCount?: number): Promise<void>;
+export declare function measurePage(page: Page): Promise<PageMetrics>;

package/dist/capture/utils.js

@@ -1,4 +1,4 @@
-import { mkdir } from 'node:fs/promises';
+import { access, mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 const LOCALHOST_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]', '::1']);
 export function clamp(value, min, max) {
@@ -13,13 +13,40 @@ export function parseCaptureUrl(rawUrl) {
         url = new URL(rawUrl);
     }
     catch {
-        throw new Error(`無効なURLです: ${rawUrl}`);
+        throw new Error(`Invalid URL: ${rawUrl}\n  Expected format: http://example.com or https://localhost:3000`);
     }
     if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        throw new Error(`サポート対象外のURLです: ${rawUrl} (http/https のみ対応)`);
+        throw new Error(`Unsupported URL: ${rawUrl} (only http:// and https:// are supported)`);
     }
     return url;
 }
+export function sanitizeUrl(url) {
+    const sanitized = new URL(url.toString());
+    sanitized.username = '';
+    sanitized.password = '';
+    return sanitized.toString();
+}
+export function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function validateHideSelector(selector) {
+    if (selector.includes('{') || selector.includes('}')) {
+        throw new Error(`Invalid CSS selector for --hide-selector: "${selector}". Selectors must not contain { or } characters.`);
+    }
+}
+export async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function ensureParentDirectory(filePath) {
     await mkdir(dirname(filePath), { recursive: true });
 }

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -1,13 +1,70 @@
 #!/usr/bin/env node
-import { CliError, formatUsage, parseCliArgs } from './options.js';
+import { statSync } from 'node:fs';
+import { basename } from 'node:path';
+import { AbortError } from './capture/capture.js';
+import { createProgressReporter } from './capture/progress.js';
+import { formatFileSize } from './capture/utils.js';
+import { CliError, formatUsage, HelpRequest, parseCommandArgs, VersionRequest, } from './options.js';
 import { runCaptureCommand } from './run-capture.js';
+import { runRenderCommand } from './run-render.js';
 async function main() {
     try {
-        const options = parseCliArgs();
-        const result = await runCaptureCommand(options);
-        process.stdout.write(`${result.capture.outPath}\n`);
+        const command = parseCommandArgs();
+        const controller = new AbortController();
+        const onSignal = () => {
+            controller.abort();
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        const progress = createProgressReporter();
+        try {
+            if (command.kind === 'capture') {
+                const result = await runCaptureCommand(command.options, progress, controller.signal);
+                process.stdout.write(`${result.capture.outPath}\n`);
+                process.stderr.write(`${formatOutputSummary({
+                    label: 'Capture complete',
+                    outPath: result.capture.outPath,
+                    durationSeconds: result.capture.durationSeconds,
+                    frameCount: result.capture.frameCount,
+                    fps: command.options.fps,
+                    sceneCount: result.capture.pages.length,
+                    manifestPath: result.manifestPath,
+                })}\n`);
+            }
+            else {
+                const result = await runRenderCommand(command.options, progress, controller.signal);
+                process.stdout.write(`${result.outputs.map((output) => output.capture.outPath).join('\n')}\n`);
+                const blocks = result.outputs.map((output) => formatOutputSummary({
+                    label: `Render complete: ${output.name}`,
+                    outPath: output.capture.outPath,
+                    durationSeconds: output.capture.durationSeconds,
+                    frameCount: output.capture.frameCount,
+                    fps: output.fps,
+                    sceneCount: output.capture.pages.length,
+                    manifestPath: output.manifestPath,
+                }));
+                process.stderr.write(`\n${blocks.join('\n\n')}\n  Summary:   ${basename(result.summaryManifestPath)}\n`);
+            }
+        }
+        finally {
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+        }
     }
     catch (error) {
+        if (error instanceof HelpRequest) {
+            process.stdout.write(`${error.message}\n`);
+            return;
+        }
+        if (error instanceof VersionRequest) {
+            process.stdout.write(`${error.version}\n`);
+            return;
+        }
+        if (error instanceof AbortError) {
+            process.stderr.write('\nCapture cancelled.\n');
+            process.exitCode = 130;
+            return;
+        }
         if (error instanceof CliError) {
             process.stderr.write(`${error.message}\n`);
             if (error.showUsage) {
@@ -16,8 +73,32 @@ async function main() {
             process.exitCode = 1;
             return;
         }
-        process.stderr.write(`${error instanceof Error ? error.message : '予期しないエラーが発生しました。'}\n`);
+        process.stderr.write(`${error instanceof Error ? error.message : 'An unexpected error occurred.'}\n`);
         process.exitCode = 1;
     }
 }
+function formatOutputSummary(input) {
+    const fileName = basename(input.outPath);
+    let fileSizeStr = '';
+    try {
+        const stat = statSync(input.outPath);
+        fileSizeStr = formatFileSize(stat.size);
+    }
+    catch {
+        // File size unavailable
+    }
+    const lines = [
+        '',
+        `${input.label}: ${fileName}`,
+        `  Duration:  ${input.durationSeconds.toFixed(1)}s (${input.frameCount} frames at ${input.fps.toFixed(0)}fps)`,
+    ];
+    if (fileSizeStr) {
+        lines.push(`  File size: ${fileSizeStr}`);
+    }
+    if (input.sceneCount > 1) {
+        lines.push(`  Scenes:    ${input.sceneCount}`);
+    }
+    lines.push(`  Manifest:  ${basename(input.manifestPath)}`);
+    return lines.join('\n');
+}
 await main();

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { captureSceneVideo, captureVideo } from './capture/capture.js';
+export type { CaptureAction, CaptureAudioTrack, CaptureJob, CaptureOptions, CaptureResult, CaptureScene, CaptureSubtitleTrack, CaptureTimelineScrollTarget, CaptureTimelineSegment, CaptureTransition, CaptureVideoEncodingSettings, FinalVideoEncodingSettings, H264Preset, IntermediateArtifactProfile, MotionCurve, OutputFormat, PageCaptureResult, Viewport, Vp9Deadline, WaitForCondition, } from './capture/types.js';
+export { DEFAULT_DURATION, DEFAULT_FPS, DEFAULT_MOTION, DEFAULT_OUT_FILE, DEFAULT_TIMEOUT_MS, DEFAULT_VIEWPORT, formatUsage, type ParsedCliCommand, parseCliArgs, parseCommandArgs, type RenderCliOptions, } from './options.js';
+export { loadRenderProject, type ResolvedRenderOutput, type ResolvedRenderProject, } from './project.js';
+export { buildArtifactMetrics, buildCaptureMetrics, buildComposedCaptureResult, buildProbeWarningEvent, buildSceneCaptureArtifact, buildSceneClipProbeFailureMessage, collectProbeWarnings, createRenderPlan, type PlannedComposition, type PlannedSceneCapture, type RenderArtifactMetrics, type RenderCaptureMetrics, type RenderPlan, type SceneCaptureArtifact, shouldFailOnSceneClipProbe, } from './render-plan.js';
+export { runCaptureCommand } from './run-capture.js';
+export { type RenderCommandResult, type RenderOutputResult, runRenderCommand, } from './run-render.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { captureSceneVideo, captureVideo } from './capture/capture.js';
+export { DEFAULT_DURATION, DEFAULT_FPS, DEFAULT_MOTION, DEFAULT_OUT_FILE, DEFAULT_TIMEOUT_MS, DEFAULT_VIEWPORT, formatUsage, parseCliArgs, parseCommandArgs, } from './options.js';
+export { loadRenderProject, } from './project.js';
+export { buildArtifactMetrics, buildCaptureMetrics, buildComposedCaptureResult, buildProbeWarningEvent, buildSceneCaptureArtifact, buildSceneClipProbeFailureMessage, collectProbeWarnings, createRenderPlan, shouldFailOnSceneClipProbe, } from './render-plan.js';
+export { runCaptureCommand } from './run-capture.js';
+export { runRenderCommand, } from './run-render.js';

package/dist/options.d.ts

@@ -0,0 +1,42 @@
+import type { CaptureOptions, MotionCurve, WaitForCondition } from './capture/types.js';
+export declare const DEFAULT_OUT_FILE = "rollberry.mp4";
+export declare const DEFAULT_VIEWPORT = "1440x900";
+export declare const DEFAULT_FPS = 60;
+export declare const DEFAULT_DURATION = "auto";
+export declare const DEFAULT_MOTION: MotionCurve;
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+export interface RenderCliOptions {
+    projectPath: string;
+    outputNames: string[];
+    force: boolean;
+}
+export type ParsedCliCommand = {
+    kind: 'capture';
+    options: CaptureOptions;
+} | {
+    kind: 'render';
+    options: RenderCliOptions;
+};
+export declare class CliError extends Error {
+    readonly showUsage: boolean;
+    constructor(message: string, showUsage?: boolean);
+}
+export declare class HelpRequest extends Error {
+    constructor(message: string);
+}
+export declare class VersionRequest extends Error {
+    readonly version = "0.1.9";
+    constructor();
+}
+export declare function parseCommandArgs(argv?: string[]): ParsedCliCommand;
+export declare function parseCliArgs(argv?: string[]): CaptureOptions;
+export declare function formatUsage(): string;
+export declare function parseWithCliError<T>(rawValue: string, parser: (value: string) => T): T;
+export declare function resolveOutPath(path: string): string;
+export declare function deriveSidecarPath(path: string, suffix: string): string;
+export declare function parseViewport(rawViewport: string): CaptureOptions['viewport'];
+export declare function parsePositiveInt(rawValue: string): number;
+export declare function parsePositiveNumber(rawValue: string): number;
+export declare function parseNonNegativeNumber(rawValue: string): number;
+export declare function parseMotion(rawMotion: string): MotionCurve;
+export declare function parseWaitFor(rawWaitFor: string): WaitForCondition;