rollberry 0.1.9 → 0.2.0

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/cli.d.ts

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

package/dist/cli.js

@@ -4,11 +4,12 @@ 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, parseCliArgs, VersionRequest, } from './options.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 command = parseCommandArgs();
         const controller = new AbortController();
         const onSignal = () => {
             controller.abort();
@@ -17,30 +18,33 @@ async function main() {
         process.on('SIGTERM', onSignal);
         const progress = createProgressReporter();
         try {
-            const result = await runCaptureCommand(options, progress, controller.signal);
-            process.stdout.write(`${result.capture.outPath}\n`);
-            const fileName = basename(result.capture.outPath);
-            let fileSizeStr = '';
-            try {
-                const stat = statSync(result.capture.outPath);
-                fileSizeStr = formatFileSize(stat.size);
+            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`);
             }
-            catch {
-                // File size unavailable
+            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`);
             }
-            const lines = [
-                '',
-                `Capture complete: ${fileName}`,
-                `  Duration:  ${result.capture.durationSeconds.toFixed(1)}s (${result.capture.frameCount} frames at ${options.fps}fps)`,
-            ];
-            if (fileSizeStr) {
-                lines.push(`  File size: ${fileSizeStr}`);
-            }
-            if (result.capture.pages.length > 1) {
-                lines.push(`  Pages:     ${result.capture.pages.length}`);
-            }
-            lines.push(`  Manifest:  ${basename(result.manifestPath)}`);
-            process.stderr.write(`${lines.join('\n')}\n`);
         }
         finally {
             process.off('SIGINT', onSignal);
@@ -73,4 +77,28 @@ async function main() {
         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;