clipwise 0.2.1 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { EventEmitter } from 'events';
 
 declare const StepActionSchema: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
     action: z.ZodLiteral<"navigate">;
@@ -492,6 +493,7 @@ declare const OutputConfigSchema: z.ZodObject<{
     height: z.ZodDefault<z.ZodNumber>;
     fps: z.ZodDefault<z.ZodNumber>;
     quality: z.ZodDefault<z.ZodNumber>;
+    preset: z.ZodOptional<z.ZodEnum<["social", "balanced", "archive"]>>;
     outputDir: z.ZodDefault<z.ZodString>;
     filename: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -502,12 +504,14 @@ declare const OutputConfigSchema: z.ZodObject<{
     quality: number;
     outputDir: string;
     filename: string;
+    preset?: "social" | "balanced" | "archive" | undefined;
 }, {
     format?: "gif" | "mp4" | "webm" | "png-sequence" | undefined;
     width?: number | undefined;
     height?: number | undefined;
     fps?: number | undefined;
     quality?: number | undefined;
+    preset?: "social" | "balanced" | "archive" | undefined;
     outputDir?: string | undefined;
     filename?: string | undefined;
 }>;
@@ -1146,6 +1150,7 @@ declare const ScenarioSchema: z.ZodObject<{
         height: z.ZodDefault<z.ZodNumber>;
         fps: z.ZodDefault<z.ZodNumber>;
         quality: z.ZodDefault<z.ZodNumber>;
+        preset: z.ZodOptional<z.ZodEnum<["social", "balanced", "archive"]>>;
         outputDir: z.ZodDefault<z.ZodString>;
         filename: z.ZodDefault<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -1156,12 +1161,14 @@ declare const ScenarioSchema: z.ZodObject<{
         quality: number;
         outputDir: string;
         filename: string;
+        preset?: "social" | "balanced" | "archive" | undefined;
     }, {
         format?: "gif" | "mp4" | "webm" | "png-sequence" | undefined;
         width?: number | undefined;
         height?: number | undefined;
         fps?: number | undefined;
         quality?: number | undefined;
+        preset?: "social" | "balanced" | "archive" | undefined;
         outputDir?: string | undefined;
         filename?: string | undefined;
     }>>;
@@ -1543,6 +1550,7 @@ declare const ScenarioSchema: z.ZodObject<{
         quality: number;
         outputDir: string;
         filename: string;
+        preset?: "social" | "balanced" | "archive" | undefined;
     };
     steps: {
         actions: ({
@@ -1749,6 +1757,7 @@ declare const ScenarioSchema: z.ZodObject<{
         height?: number | undefined;
         fps?: number | undefined;
         quality?: number | undefined;
+        preset?: "social" | "balanced" | "archive" | undefined;
         outputDir?: string | undefined;
         filename?: string | undefined;
     } | undefined;
@@ -1775,6 +1784,8 @@ interface CapturedFrame {
         width: number;
         height: number;
     };
+    /** Device pixel ratio used during capture (1 = normal, 2 = Retina/HiDPI). */
+    deviceScaleFactor?: number;
     stepName?: string;
     stepIndex?: number;
     actionType?: string;
@@ -1784,12 +1795,45 @@ interface ComposedFrame {
     index: number;
     buffer: Buffer;
     timestamp: number;
+    /**
+     * Present when buffer contains raw RGBA pixels (not PNG).
+     * Allows the encoder to skip the PNG-decode step and consume pixels directly.
+     */
+    rawInfo?: {
+        width: number;
+        height: number;
+        channels: 4;
+    };
+}
+interface DedupStats {
+    /** CDP로부터 수신한 원본 프레임 수 */
+    received: number;
+    /** 중복 제거 후 실제 저장된 고유 프레임 수 */
+    stored: number;
+    /** 중복으로 판단해 건너뛴 프레임 수 */
+    skipped: number;
 }
 interface RecordingSession {
     scenario: Scenario;
     frames: CapturedFrame[];
     startTime: number;
     endTime?: number;
+    /** 정적 프레임 중복 제거 통계 */
+    dedupStats?: DedupStats;
+}
+/**
+ * Handle returned by ClipwiseRecorder.recordToChannel().
+ *
+ * frameStream: async iterable of CapturedFrames as they are captured
+ *   (post-dedup, no FPS resampling — frames arrive at CDP capture rate).
+ *   Closes automatically when recording ends.
+ *
+ * done: resolves with the full RecordingSession (including FPS-resampled
+ *   frames) when recording has completely finished.
+ */
+interface RecordingHandle {
+    frameStream: AsyncIterable<CapturedFrame>;
+    done: Promise<RecordingSession>;
 }
 
 declare class ClipwiseRecorder {
@@ -1804,11 +1848,16 @@ declare class ClipwiseRecorder {
     private currentStepIndex;
     private cursorPosition;
     private viewport;
+    private deviceScaleFactor;
     private isCapturing;
     private targetFps;
     private cursorSpeed;
     private firstContentTimestamp;
     private pendingResponsePromises;
+    private lastFrameSignature;
+    private dedupStats;
+    private frameChannel;
+    private channelIndex;
     /**
      * Launch the browser and create a page with the scenario viewport.
      */
@@ -1826,6 +1875,26 @@ declare class ClipwiseRecorder {
      * Execute the full scenario with continuous capture and return a RecordingSession.
      */
     record(scenario: Scenario): Promise<RecordingSession>;
+    /**
+     * Start recording concurrently and return a RecordingHandle immediately.
+     *
+     * frameStream: yields CapturedFrames as each unique frame arrives from CDP
+     *   (post-dedup, sequential indices starting at 0, NO FPS resampling).
+     *   Closes when recording ends.
+     *
+     * done: resolves with the full RecordingSession (FPS-resampled) once
+     *   all steps have completed and the browser has been cleaned up.
+     *
+     * Use this with CanvasRenderer.composeStreamOnline() to overlap recording
+     * time with composition time — total wall-clock ≈ max(recordingMs, composeMs).
+     */
+    recordToChannel(scenario: Scenario): RecordingHandle;
+    /**
+     * Build a single CapturedFrame from a RawFrame in real-time.
+     * Used by recordToChannel() to emit frames as they arrive.
+     * Cursor/click data reflects the timeline up to this moment.
+     */
+    private buildFrameOnline;
     /**
      * Wait for a given duration while forcing periodic repaints
      * so CDP screencast keeps sending frames even on static pages.
@@ -1868,12 +1937,41 @@ declare class ClipwiseRecorder {
      * Interpolate cursor position at a given timestamp using the cursor timeline.
      */
     private interpolateCursorAt;
+    /**
+     * Binary search: returns the index of the last entry whose timestamp <= target.
+     * Assumes the array is sorted by timestamp in ascending order.
+     */
+    private binarySearchTimeline;
     /**
      * Clean up browser resources. Always called after recording.
      */
     cleanup(): Promise<void>;
 }
 
+/**
+ * Pre-computed static layers that are identical for every frame in a session.
+ *
+ * backdropRaw: background gradient + shadow + watermark composited together at
+ *   output dimensions, stored as raw RGBA.  Workers composite the per-frame
+ *   screenshot onto this buffer instead of re-generating the background SVG
+ *   and shadow SVG on every frame — eliminating ~3 PNG encode/decode cycles.
+ *
+ * browserChromePng: pre-rasterized browser chrome bar PNG.  Applied via
+ *   Sharp's .extend() + .composite() in a single pipeline pass instead of the
+ *   current two-pass create-blank-canvas + composite pattern.
+ *
+ * Both are computed once per worker (first frame), then cached in memory for
+ * all subsequent frames handled by that worker.
+ */
+interface StaticLayers {
+    backdropRaw: Buffer;
+    backdropWidth: number;
+    backdropHeight: number;
+    /** Pre-rasterized browser chrome bar PNG.  Null when device frame is disabled or not "browser". */
+    browserChromePng: Buffer | null;
+    /** Pixel height of the chrome bar (0 when browserChromePng is null). */
+    browserChromeHeight: number;
+}
 interface FrameContext {
     zoomScale: number;
     clickProgress: number | null;
@@ -1881,26 +1979,18 @@ interface FrameContext {
         x: number;
         y: number;
     }>;
+    /** When present, skip redundant per-frame SVG generation for background/watermark/device-frame. */
+    staticLayers?: StaticLayers;
 }
+
 declare class CanvasRenderer {
     private effects;
     private output;
     private steps;
     constructor(effects: EffectsConfig, output: OutputConfig, steps?: Step[]);
     /**
-     * Apply the full effects pipeline to a single captured frame.
-     *
-     * Pipeline order:
-     *  1. Device frame (browser chrome / mobile mockup)
-     *  2. Cursor highlight (Screen Studio glow)
-     *  3. Cursor trail
-     *  4. Cursor rendering
-     *  5. Click ripple effect (animated progress)
-     *  6. Keystroke HUD
-     *  7. Zoom (adaptive, cursor-following)
-     *  8. Background (padding, gradient, rounded corners)
-     *  9. Watermark overlay
-     *  10. Final resize
+     * Apply the full effects pipeline to a single frame.
+     * Delegates to the standalone composeFrame function.
      */
     composeFrame(frame: CapturedFrame, context?: Partial<FrameContext>): Promise<ComposedFrame>;
     /**
@@ -1909,22 +1999,96 @@ declare class CanvasRenderer {
      * Multi-pass approach:
      *   Pass 1: Speed ramping (adjust frame set).
      *   Pass 2: Calculate per-frame contexts (zoom, click, trail).
-     *   Pass 3: Render each frame with effects.
+     *   Pass 3: Render frames in parallel using worker threads.
      *   Pass 4: Apply scene transitions at step boundaries.
      */
     composeAll(frames: CapturedFrame[]): Promise<ComposedFrame[]>;
     /**
-     * Calculate per-frame rendering context (zoom, click progress, cursor trail, tilt).
+     * Distribute frame composition across a pool of worker threads.
+     * Workers process frames concurrently; results are collected in order.
+     */
+    private processWithWorkers;
+    /**
+     * Calculate per-frame rendering context (zoom scale, click progress, cursor trail).
      */
     private calculateFrameContexts;
     /**
      * Apply speed ramping: slow down near actions, speed up during idle.
-     * Returns a new frame array with frames duplicated or skipped.
      */
     private applySpeedRamp;
+    /**
+     * Returns true when no effect requires the full frame array upfront.
+     *
+     * When true, composeStreamOnline() can be used: frames are composited as they
+     * arrive (no need to wait for all frames to be collected first).
+     *
+     * Currently the only blocking effect is speed ramp, which needs to scan all
+     * frames to compute action-proximity indices.  Zoom uses the window-based
+     * calculateAdaptiveZoomInWindow() so it works with a rolling lookahead buffer.
+     */
+    canStreamOnline(): boolean;
+    /**
+     * Online streaming compose — accepts an AsyncIterable of frames (e.g. from
+     * ClipwiseRecorder.recordToChannel()) and begins compositing immediately,
+     * without waiting for all frames to be collected.
+     *
+     * Each frame is dispatched to the worker pool as soon as its zoom lookahead
+     * window is satisfied (i.e. when frame i + transitionFrames has arrived).
+     * This creates a natural pipeline: recording produces frames while workers
+     * consume them in parallel.
+     *
+     * Requires canStreamOnline() === true (speedRamp must be disabled).
+     * Transitions (step boundaries with transition: fade) are applied inline
+     * using the same applyTransitionsToStream() logic as composeStream().
+     */
+    composeStreamOnline(source: AsyncIterable<CapturedFrame>): AsyncGenerator<ComposedFrame>;
+    /**
+     * Worker-pool online streaming: dispatches frame i to a worker as soon as
+     * frame i + transitionFrames has arrived from the source.
+     *
+     * Uses a notify-on-progress pattern (same as streamWithWorkers) extended
+     * with an intake coroutine that feeds the growing frames[] buffer.
+     */
+    private streamOnlineWithWorkers;
+    /**
+     * Stream frame composition — yields ComposedFrames as workers finish,
+     * in display order, so the encoder can start before all frames are composed.
+     *
+     * Same 4-pass structure as composeAll():
+     *   Pass 1 & 2 run upfront (need the full frame set).
+     *   Pass 3 streams via the worker pool (ordered yield).
+     *   Pass 4 transitions are buffered inline and applied at step boundaries.
+     */
+    composeStream(frames: CapturedFrame[]): AsyncGenerator<ComposedFrame>;
+    /**
+     * Worker-pool streaming: dispatches frames to workers and yields results
+     * in display order as soon as each frame is ready.
+     *
+     * Uses a notify-on-progress pattern to bridge event-driven workers
+     * to an ordered AsyncGenerator without busy-polling.
+     */
+    private streamWithWorkers;
+    /**
+     * Sequential streaming fallback for small frame counts where worker
+     * thread overhead would exceed the parallelism benefit.
+     */
+    private streamSequential;
+    /**
+     * Pre-compute [startIdx, endIdx] windows for every fade transition so that
+     * applyTransitionsToStream can buffer only those frames.
+     */
+    private getTransitionWindows;
+    /**
+     * Wrap a ComposedFrame stream with inline transition buffering.
+     *
+     * Non-transition frames are yielded immediately.
+     * Frames inside a fade window are held until both endpoints are available,
+     * then the crossfade is applied and all window frames are flushed in order.
+     * A pending map maintains global display order across window boundaries.
+     */
+    private applyTransitionsToStream;
     /**
      * Apply crossfade transitions at step boundaries where configured.
-     * Modifies the composed array in-place.
      */
     private applyTransitions;
 }
@@ -1935,26 +2099,130 @@ declare class CanvasRenderer {
  */
 declare function encodeGif(frames: ComposedFrame[], config: OutputConfig): Promise<Buffer>;
 /**
- * Encode a sequence of composed frames into an MP4 file using ffmpeg.
- * Writes frames as PNG sequence to a temp directory, then runs ffmpeg.
+ * Encode a sequence of composed frames into an MP4 buffer.
+ *
+ * Uses FFmpeg stdin piping (raw video) to eliminate disk I/O overhead.
+ * Encoder priority: hevc_videotoolbox (macOS HEVC HW) → h264_videotoolbox
+ * (macOS H.264 HW) → libx264 (software fallback).
+ *
+ * Encoding quality is controlled by the output.preset field:
+ *   social   — screen-recording quality, ~2–4 MB / 30s
+ *   balanced — high fidelity, ~4–8 MB / 30s
+ *   archive  — near-lossless, uncapped bitrate
  *
  * Requires ffmpeg to be installed and available in PATH.
  */
 declare function encodeMp4(frames: ComposedFrame[], config: OutputConfig): Promise<Buffer>;
+/**
+ * Streaming variant of encodeMp4 — accepts an AsyncIterable so frames can
+ * be piped to FFmpeg as they arrive from the composition pipeline,
+ * overlapping composition and encoding rather than waiting for all frames.
+ */
+declare function encodeMp4Stream(frames: AsyncIterable<ComposedFrame>, config: OutputConfig): Promise<Buffer>;
 /**
  * Save a sequence of composed frames as individual PNG files.
- * Returns an array of file paths for the saved images.
  */
 declare function savePngSequence(frames: ComposedFrame[], config: OutputConfig): Promise<string[]>;
 
+/**
+ * Emitted by StreamingSession after each frame is composed.
+ */
+interface PipelineProgress {
+    /** Number of frames composed so far */
+    composed: number;
+    /** Total frames in the session */
+    total: number;
+    /** Completion percentage (0–100) */
+    pct: number;
+}
+interface ConcurrentResult {
+    /** Fully-encoded MP4 buffer. */
+    buffer: Buffer;
+    /** Full RecordingSession (FPS-resampled) returned when recording completed. */
+    session: RecordingSession;
+}
+/**
+ * ConcurrentSession overlaps recording and composition in the same process.
+ *
+ * While the recorder captures CDP screencast frames, the compositor begins
+ * applying effects immediately — each frame is dispatched to the worker pool
+ * as soon as its zoom lookahead window is satisfied.
+ *
+ * Total wall-clock time ≈ max(recordingMs, composeMs) instead of the sum.
+ * Requires renderer.canStreamOnline() === true (speedRamp must be disabled).
+ *
+ * Emits 'progress' after each composed frame.
+ * During recording the total is unknown (pct = -1); after recording ends and
+ * composition finishes, a final event with pct = 100 is emitted.
+ *
+ * Usage:
+ *   const pipeline = new ConcurrentSession(recorder, scenario, renderer);
+ *   pipeline.on("progress", ({ composed, total, pct }) => {
+ *     spinner.text = total > 0
+ *       ? `Processing... ${composed}/${total} (${pct}%)`
+ *       : `Recording & composing... ${composed} frames`;
+ *   });
+ *   const { buffer, session } = await pipeline.run();
+ */
+declare class ConcurrentSession extends EventEmitter {
+    private readonly recorder;
+    private readonly scenario;
+    private readonly renderer;
+    constructor(recorder: ClipwiseRecorder, scenario: Scenario, renderer: CanvasRenderer);
+    /**
+     * Start recording and compositing concurrently.
+     * Returns when both recording and encoding are complete.
+     */
+    run(): Promise<ConcurrentResult>;
+}
+/**
+ * StreamingSession bridges a recorded session to the compose+encode streaming
+ * pipeline and emits fine-grained progress events.
+ *
+ * Emits:
+ *   'progress' — after each frame is composed, with a PipelineProgress payload
+ *
+ * Usage:
+ *   const pipeline = new StreamingSession(session, renderer);
+ *   pipeline.on("progress", ({ composed, total, pct }) => {
+ *     spinner.text = `Composing & encoding... ${composed}/${total} (${pct}%)`;
+ *   });
+ *   const mp4Buffer = await pipeline.run();
+ */
+declare class StreamingSession extends EventEmitter {
+    private readonly session;
+    private readonly renderer;
+    constructor(session: RecordingSession, renderer: CanvasRenderer);
+    /** Total frames in the underlying recording session. */
+    get totalFrames(): number;
+    /**
+     * Run the compose → encode pipeline.
+     *
+     * Composes frames via the worker pool (Phase 1-B streaming, ordered yield),
+     * forwarding each to FFmpeg as it completes.  Emits a 'progress' event after
+     * every composed frame so callers can update a spinner or progress bar.
+     *
+     * @returns The fully-encoded MP4 as a Buffer.
+     */
+    run(): Promise<Buffer>;
+}
+
 /**
  * Calculate adaptive zoom scale based on proximity to click/action frames.
  * Zooms in smoothly near important actions, stays at 1.0 during idle.
  *
+ * Scans only the ±transitionFrames influence window — frames outside that
+ * range always produce 1.0 anyway, so scanning the full array is wasted work.
+ * This reduces per-call cost from O(n) to O(transitionFrames).
+ *
+ * For bulk context calculation over many frames, prefer the lookup-based API:
+ *   buildZoomClickLookup() once → calculateAdaptiveZoomFromLookup() per frame
+ * which achieves O(n + n·log k) instead of O(n·transitionFrames).
+ *
  * @param frames - Array of frames with optional clickPosition
  * @param currentIndex - Index of the current frame
  * @param maxScale - Peak zoom scale
- * @param transitionFrames - Number of frames for zoom-in/zoom-out transition
+ * @param transitionFrames - Half-width of the zoom influence window (frames)
  * @returns Scale value for the current frame (1.0 = no zoom)
  */
 declare function calculateAdaptiveZoom(frames: Array<{
@@ -1963,6 +2231,42 @@ declare function calculateAdaptiveZoom(frames: Array<{
         y: number;
     } | null;
 }>, currentIndex: number, maxScale: number, transitionFrames: number): number;
+/**
+ * Pre-extract the indices of all click frames in a single O(n) pass.
+ * Pass the result to calculateAdaptiveZoomFromLookup() for O(log k) per-frame
+ * zoom computation, instead of O(transitionFrames) per frame.
+ *
+ * @returns Sorted array of frame indices that carry a clickPosition.
+ */
+declare function buildZoomClickLookup(frames: ReadonlyArray<{
+    clickPosition: unknown;
+}>): number[];
+/**
+ * Calculate adaptive zoom scale using a pre-built click index lookup.
+ * Binary-searches the lookup for the nearest click — O(log k) per call.
+ *
+ * Use buildZoomClickLookup() once before iterating, then call this per frame.
+ *
+ * @param clickLookup - Sorted array of click frame indices from buildZoomClickLookup()
+ * @param currentIndex - Index of the frame being evaluated
+ */
+declare function calculateAdaptiveZoomFromLookup(clickLookup: readonly number[], currentIndex: number, maxScale: number, transitionFrames: number): number;
+/**
+ * Calculate adaptive zoom scale using only a local window of frames.
+ * Does NOT need the full frame array — only frames within
+ * [currentIndex - transitionFrames, currentIndex + transitionFrames].
+ *
+ * This is the Phase 3-A compatible API: when composition runs concurrently
+ * with recording, only the ±transitionFrames lookahead buffer needs to be
+ * available before frame i can be composed.
+ *
+ * @param windowFrames - Slice of frames around currentIndex
+ * @param windowStart  - Absolute timeline index of windowFrames[0]
+ * @param currentIndex - Absolute timeline index of the frame being composed
+ */
+declare function calculateAdaptiveZoomInWindow(windowFrames: ReadonlyArray<{
+    clickPosition: unknown;
+}>, windowStart: number, currentIndex: number, maxScale: number, transitionFrames: number): number;
 /**
  * Calculate pan offset to keep a focus point centered when zoomed in.
  * The offset defines the top-left corner of the visible crop region.
@@ -1982,38 +2286,50 @@ declare function lerpZoom(current: number, target: number, factor: number): numb
 type CursorEffect = EffectsConfig["cursor"];
 /**
  * Render a glowing highlight circle around the cursor (Screen Studio style).
+ * @param dpr - Device pixel ratio (default 1). Scales position and size for HiDPI.
  */
 declare function renderCursorHighlight(frameBuffer: Buffer, position: {
     x: number;
     y: number;
-}, config: CursorEffect, frameWidth: number, frameHeight: number): Promise<Buffer>;
+}, config: CursorEffect, frameWidth: number, frameHeight: number, dpr?: number): Promise<Buffer>;
 /**
  * Render a cursor trail (fading line segments following cursor path).
  * Each segment fades from transparent (oldest) to opaque (newest).
+ * @param dpr - Device pixel ratio (default 1). Scales positions for HiDPI.
  */
 declare function renderCursorTrail(frameBuffer: Buffer, positions: Array<{
     x: number;
     y: number;
-}>, config: CursorEffect, frameWidth: number, frameHeight: number): Promise<Buffer>;
+}>, config: CursorEffect, frameWidth: number, frameHeight: number, dpr?: number): Promise<Buffer>;
 
 type KeystrokeConfig = EffectsConfig["keystroke"];
 /**
  * Render a keystroke HUD overlay showing recently typed keys.
  * Inspired by KeyCastr / CursorClip.
  */
-declare function renderKeystrokeHud(frameBuffer: Buffer, keystrokes: KeystrokeEvent[], frameTimestamp: number, config: KeystrokeConfig, frameWidth: number, frameHeight: number): Promise<Buffer>;
+declare function renderKeystrokeHud(frameBuffer: Buffer, keystrokes: KeystrokeEvent[], frameTimestamp: number, config: KeystrokeConfig, frameWidth: number, frameHeight: number, dpr?: number): Promise<Buffer>;
 
+type RawInfo = {
+    width: number;
+    height: number;
+    channels: 4;
+};
 /**
  * Apply a crossfade transition between two frame buffers.
  * Uses raw pixel weighted averaging for accurate blending.
  *
- * @param fromBuffer - The outgoing frame
- * @param toBuffer   - The incoming frame
- * @param progress   - 0 = fully "from", 1 = fully "to"
- * @param width      - Frame width
- * @param height     - Frame height
+ * @param fromBuffer  - The outgoing frame (PNG or raw RGBA)
+ * @param toBuffer    - The incoming frame (PNG or raw RGBA)
+ * @param progress    - 0 = fully "from", 1 = fully "to"
+ * @param width       - Frame width
+ * @param height      - Frame height
+ * @param fromRawInfo - Pass when fromBuffer is raw RGBA
+ * @param toRawInfo   - Pass when toBuffer is raw RGBA
  */
-declare function applyCrossfade(fromBuffer: Buffer, toBuffer: Buffer, progress: number, width: number, height: number): Promise<Buffer>;
+declare function applyCrossfade(fromBuffer: Buffer, toBuffer: Buffer, progress: number, width: number, height: number, fromRawInfo?: RawInfo, toRawInfo?: RawInfo): Promise<{
+    buffer: Buffer;
+    rawInfo: RawInfo;
+}>;
 
 type WatermarkConfig = EffectsConfig["watermark"];
 /**
@@ -2042,4 +2358,4 @@ interface ValidationResult {
  */
 declare function validateScenario(scenario: Scenario): ValidationResult;
 
-export { CanvasRenderer, type CapturedFrame, ClipwiseRecorder, type ComposedFrame, type EffectsConfig, type FrameContext, type KeystrokeEvent, type OutputConfig, type RecordingSession, type Scenario, type Step, type StepAction, applyCrossfade, calculateAdaptiveZoom, calculatePanOffset, encodeGif, encodeMp4, lerpZoom, loadScenario, parseScenario, renderCursorHighlight, renderCursorTrail, renderKeystrokeHud, renderWatermark, savePngSequence, validateScenario };
+export { CanvasRenderer, type CapturedFrame, ClipwiseRecorder, type ComposedFrame, type ConcurrentResult, ConcurrentSession, type EffectsConfig, type FrameContext, type KeystrokeEvent, type OutputConfig, type PipelineProgress, type RecordingHandle, type RecordingSession, type Scenario, type Step, type StepAction, StreamingSession, applyCrossfade, buildZoomClickLookup, calculateAdaptiveZoom, calculateAdaptiveZoomFromLookup, calculateAdaptiveZoomInWindow, calculatePanOffset, encodeGif, encodeMp4, encodeMp4Stream, lerpZoom, loadScenario, parseScenario, renderCursorHighlight, renderCursorTrail, renderKeystrokeHud, renderWatermark, savePngSequence, validateScenario };