rollberry 0.1.8 → 0.2.0

package/dist/render-plan.d.ts

@@ -0,0 +1,103 @@
+import type { VideoProbeOutcome } from './capture/ffmpeg.js';
+import type { CaptureJob, CaptureResult, CaptureScene, FinalVideoEncodingSettings, IntermediateArtifactProfile, NonEmptyArray, PageCaptureResult } from './capture/types.js';
+import type { ResolvedRenderOutput } from './project.js';
+export interface PlannedSceneCapture {
+    sceneIndex: number;
+    scene: CaptureScene;
+    clipPath: string;
+    debugFramesDir?: string;
+    job: CaptureJob;
+}
+export interface PlannedComposition {
+    outPath: string;
+    format: ResolvedRenderOutput['format'];
+    fps: number;
+    audio: ResolvedRenderOutput['audio'];
+    subtitles: ResolvedRenderOutput['subtitles'];
+    transition: ResolvedRenderOutput['transition'];
+    finalVideo: FinalVideoEncodingSettings;
+    force: boolean;
+}
+export interface CompositionCapabilities {
+    requiresPreciseClipTiming: boolean;
+    timingRequirementSources: string[];
+}
+export interface RenderPlan {
+    output: ResolvedRenderOutput;
+    tempDir: string;
+    sceneCaptures: NonEmptyArray<PlannedSceneCapture>;
+    composition: PlannedComposition;
+    capabilities: CompositionCapabilities;
+}
+export interface SceneCaptureArtifact {
+    captureMetrics: CaptureResult;
+    clip: {
+        path: string;
+        durationSeconds: number;
+        frameCount?: number;
+    };
+    probe: VideoProbeOutcome;
+}
+export interface RenderCaptureMetrics {
+    frameCount: number;
+    durationSeconds: number;
+    truncated: boolean;
+    scenes: PageCaptureResult[];
+}
+export interface RenderArtifactMetrics {
+    videoPath: string;
+    frameCount: number;
+    durationSeconds: number;
+    truncated: boolean;
+    probe: {
+        status: VideoProbeOutcome['status'];
+        source: 'ffprobe' | 'estimate';
+        warning?: string;
+    };
+}
+export declare function createRenderPlan(input: {
+    output: ResolvedRenderOutput;
+    scenes: NonEmptyArray<CaptureScene>;
+    timeoutMs: number;
+    tempDir: string;
+}): RenderPlan;
+export declare function buildSceneCaptureArtifact(input: {
+    rawCapture: CaptureResult;
+    clipPath: string;
+    probe: VideoProbeOutcome;
+}): SceneCaptureArtifact;
+export declare function buildCaptureMetrics(sceneArtifacts: SceneCaptureArtifact[]): RenderCaptureMetrics;
+export declare function buildArtifactMetrics(input: {
+    captureResult: CaptureResult;
+    probe: VideoProbeOutcome;
+}): RenderArtifactMetrics;
+export declare function collectProbeWarnings(sceneArtifacts: SceneCaptureArtifact[], finalProbe: VideoProbeOutcome): string[];
+export declare function shouldFailOnSceneClipProbe(input: {
+    probe: VideoProbeOutcome;
+    capabilities: CompositionCapabilities;
+}): boolean;
+export declare function buildSceneClipProbeFailureMessage(input: {
+    sceneIndex: number;
+    probe: VideoProbeOutcome;
+    capabilities: CompositionCapabilities;
+}): string;
+export declare function buildProbeWarningEvent(input: {
+    target: 'scene-clip' | 'output';
+    index?: number;
+    probe: VideoProbeOutcome;
+}): {
+    event: string;
+    message: string;
+    metadata: Record<string, unknown>;
+} | null;
+export declare function resolveCompositionCapabilities(input: {
+    transition?: ResolvedRenderOutput['transition'];
+    intermediateArtifact: IntermediateArtifactProfile;
+}): CompositionCapabilities;
+export declare function buildComposedCaptureResult(input: {
+    outPath: string;
+    fps: number;
+    sceneArtifacts: SceneCaptureArtifact[];
+    transition?: ResolvedRenderOutput['transition'];
+    probe: VideoProbeOutcome;
+}): CaptureResult;

package/dist/render-plan.js

@@ -0,0 +1,144 @@
+import { join } from 'node:path';
+export function createRenderPlan(input) {
+    const { output, scenes, timeoutMs, tempDir } = input;
+    const sceneCaptures = scenes.map((scene, sceneIndex) => {
+        const clipPath = join(tempDir, `scene-${String(sceneIndex + 1).padStart(3, '0')}${output.intermediateArtifact.extension}`);
+        const debugFramesDir = output.debugFramesDir
+            ? join(output.debugFramesDir, `scene-${String(sceneIndex + 1).padStart(3, '0')}`)
+            : undefined;
+        return {
+            sceneIndex,
+            scene,
+            clipPath,
+            debugFramesDir,
+            job: {
+                scenes: [scene],
+                outPath: clipPath,
+                format: output.intermediateArtifact.format,
+                viewport: output.viewport,
+                fps: output.fps,
+                timeoutMs,
+                debugFramesDir,
+                videoEncoding: output.intermediateArtifact.videoEncoding,
+                includeHoldAfterFinalScene: sceneIndex < scenes.length - 1,
+                force: true,
+            },
+        };
+    });
+    return {
+        output,
+        tempDir,
+        sceneCaptures,
+        composition: {
+            outPath: output.outPath,
+            format: output.format,
+            fps: output.fps,
+            audio: output.audio,
+            subtitles: output.subtitles,
+            transition: output.transition,
+            finalVideo: output.finalVideo,
+            force: output.force,
+        },
+        capabilities: resolveCompositionCapabilities({
+            transition: output.transition,
+            intermediateArtifact: output.intermediateArtifact,
+        }),
+    };
+}
+export function buildSceneCaptureArtifact(input) {
+    const durationSeconds = input.probe.result?.durationSeconds ?? input.rawCapture.durationSeconds;
+    const frameCount = input.probe.result?.frameCount ?? input.rawCapture.frameCount;
+    return {
+        captureMetrics: input.rawCapture,
+        clip: {
+            path: input.clipPath,
+            durationSeconds,
+            frameCount,
+        },
+        probe: input.probe,
+    };
+}
+export function buildCaptureMetrics(sceneArtifacts) {
+    return {
+        frameCount: sceneArtifacts.reduce((sum, artifact) => sum + artifact.captureMetrics.frameCount, 0),
+        durationSeconds: sceneArtifacts.reduce((sum, artifact) => sum + artifact.captureMetrics.durationSeconds, 0),
+        truncated: sceneArtifacts.some((artifact) => artifact.captureMetrics.truncated),
+        scenes: sceneArtifacts.flatMap((artifact) => artifact.captureMetrics.pages),
+    };
+}
+export function buildArtifactMetrics(input) {
+    return {
+        videoPath: input.captureResult.outPath,
+        frameCount: input.captureResult.frameCount,
+        durationSeconds: input.captureResult.durationSeconds,
+        truncated: input.captureResult.truncated,
+        probe: {
+            status: input.probe.status,
+            source: input.probe.status === 'probed' ? 'ffprobe' : 'estimate',
+            warning: input.probe.warning,
+        },
+    };
+}
+export function collectProbeWarnings(sceneArtifacts, finalProbe) {
+    const warnings = new Set();
+    for (const artifact of sceneArtifacts) {
+        if (artifact.probe.status !== 'probed') {
+            warnings.add(`scene_clip_probe_${artifact.probe.status}`);
+        }
+    }
+    if (finalProbe.status !== 'probed') {
+        warnings.add(`output_probe_${finalProbe.status}`);
+    }
+    return [...warnings];
+}
+export function shouldFailOnSceneClipProbe(input) {
+    return (input.probe.status !== 'probed' &&
+        input.capabilities.requiresPreciseClipTiming);
+}
+export function buildSceneClipProbeFailureMessage(input) {
+    return `Scene clip probe failed for scene ${input.sceneIndex + 1} (${input.probe.status}). Precise clip timing is required by: ${input.capabilities.timingRequirementSources.join(', ')}. ${input.probe.warning ?? ''}`.trim();
+}
+export function buildProbeWarningEvent(input) {
+    if (input.probe.status === 'probed') {
+        return null;
+    }
+    return {
+        event: 'probe.warning',
+        message: input.target === 'scene-clip'
+            ? 'Scene clip probe warning'
+            : 'Output probe warning',
+        metadata: {
+            target: input.target,
+            index: input.index,
+            status: input.probe.status,
+            warning: input.probe.warning,
+        },
+    };
+}
+export function resolveCompositionCapabilities(input) {
+    const timingRequirementSources = [];
+    if (input.transition?.kind === 'crossfade') {
+        timingRequirementSources.push('transition:crossfade');
+    }
+    return {
+        requiresPreciseClipTiming: timingRequirementSources.length > 0,
+        timingRequirementSources,
+    };
+}
+export function buildComposedCaptureResult(input) {
+    const pages = input.sceneArtifacts.flatMap((artifact) => artifact.captureMetrics.pages);
+    const totalClipDurationSeconds = input.sceneArtifacts.reduce((sum, artifact) => sum + artifact.clip.durationSeconds, 0);
+    const transitionOverlapSeconds = input.transition?.kind === 'crossfade'
+        ? input.transition.durationSeconds * Math.max(0, pages.length - 1)
+        : 0;
+    const estimatedDurationSeconds = Math.max(0, totalClipDurationSeconds - transitionOverlapSeconds);
+    const durationSeconds = input.probe.result?.durationSeconds ?? estimatedDurationSeconds;
+    return {
+        outPath: input.outPath,
+        frameCount: input.probe.result?.frameCount ??
+            Math.max(1, Math.round(durationSeconds * input.fps)),
+        durationSeconds,
+        pages,
+        truncated: input.sceneArtifacts.some((artifact) => artifact.captureMetrics.truncated),
+    };
+}

package/dist/run-capture.d.ts

@@ -0,0 +1,3 @@
+import type { ProgressReporter } from './capture/progress.js';
+import type { CaptureOptions, CaptureRunResult } from './capture/types.js';
+export declare function runCaptureCommand(options: CaptureOptions, progress?: ProgressReporter, signal?: AbortSignal): Promise<CaptureRunResult>;

package/dist/run-capture.js

@@ -1,22 +1,26 @@
 import { writeFile } from 'node:fs/promises';
-import { captureVideo } from './capture/capture.js';
+import { AbortError, captureVideo } from './capture/capture.js';
 import { createCaptureLogger } from './capture/logger.js';
-export async function runCaptureCommand(options) {
+import { sanitizeUrl } from './capture/utils.js';
+export async function runCaptureCommand(options, progress, signal) {
     const logger = createCaptureLogger(options.logFilePath);
     const startedAt = new Date();
+    let capture;
+    const sanitizedUrls = options.urls.map((u) => sanitizeUrl(u));
     await logger.info('capture.start', 'Capture started', {
-        urls: options.urls.map((u) => u.toString()),
+        urls: sanitizedUrls,
         outPath: options.outPath,
         manifestPath: options.manifestPath,
         logFilePath: options.logFilePath,
     });
     try {
-        const capture = await captureVideo(options, logger);
+        capture = await captureVideo(options, logger, progress, signal);
         const finishedAt = new Date();
         const warnings = capture.truncated ? ['scroll_height_truncated'] : [];
         const manifest = buildManifest({
             status: 'succeeded',
             options,
+            sanitizedUrls,
             startedAt,
             finishedAt,
             warnings,
@@ -38,16 +42,22 @@ export async function runCaptureCommand(options) {
     }
     catch (error) {
         const finishedAt = new Date();
+        const isCancelled = error instanceof AbortError;
+        const warnings = capture?.truncated ? ['scroll_height_truncated'] : [];
         const manifest = buildManifest({
-            status: 'failed',
+            status: isCancelled ? 'cancelled' : 'failed',
             options,
+            sanitizedUrls,
             startedAt,
             finishedAt,
-            warnings: [],
-            videoCreated: false,
-            error,
+            warnings,
+            videoCreated: capture !== undefined,
+            result: capture,
+            error: isCancelled ? undefined : error,
         });
-        await logger.error('capture.failed', 'Capture failed', {
+        const logEvent = isCancelled ? 'capture.cancelled' : 'capture.failed';
+        const logMessage = isCancelled ? 'Capture cancelled' : 'Capture failed';
+        await logger.error(logEvent, logMessage, {
             name: manifest.error?.name,
             message: manifest.error?.message,
             manifestPath: options.manifestPath,
@@ -75,7 +85,7 @@ function buildManifest(input) {
             arch: process.arch,
         },
         options: {
-            urls: input.options.urls.map((u) => u.toString()),
+            urls: input.sanitizedUrls,
             viewport: input.options.viewport,
             fps: input.options.fps,
             duration: input.options.duration,

package/dist/run-render.d.ts

@@ -0,0 +1,17 @@
+import type { ProgressReporter } from './capture/progress.js';
+import type { CaptureResult } from './capture/types.js';
+import type { RenderCliOptions } from './options.js';
+export interface RenderOutputResult {
+    name: string;
+    fps: number;
+    format: 'mp4' | 'webm';
+    capture: CaptureResult;
+    manifestPath: string;
+    logFilePath: string;
+}
+export interface RenderCommandResult {
+    projectPath: string;
+    summaryManifestPath: string;
+    outputs: RenderOutputResult[];
+}
+export declare function runRenderCommand(options: RenderCliOptions, progress?: ProgressReporter, signal?: AbortSignal): Promise<RenderCommandResult>;