@ct-player/embed 1.2.1 → 1.2.3

package/dist/index.d.ts

@@ -1,7 +1,7 @@
+import Hls from 'hls.js';
 import * as React__default from 'react';
 import React__default__default from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import Hls from 'hls.js';
 
 /**
  * CT Format Event Types
@@ -11,7 +11,7 @@ import Hls from 'hls.js';
 /**
  * All possible event types in the .ct format
  */
-type CTEventType = 'init' | 'code' | 'code_edit' | 'language' | 'terminal' | 'terminal_input' | 'stroke_start' | 'whiteboard_points' | 'stroke_end' | 'whiteboard_stroke' | 'whiteboard_clear' | 'whiteboard_undo' | 'whiteboard' | 'whiteboard_point' | 'excalidraw_scene' | 'excalidraw_clear' | 'excalidraw_pointer' | 'overlay_scene' | 'overlay_clear' | 'overlay_pointer' | 'document_load' | 'document_page' | 'document_zoom' | 'document_scroll' | 'document_clear' | 'file_create' | 'file_update' | 'file_delete' | 'file_rename' | 'file_switch' | 'folder_create' | 'folder_delete' | 'file_select' | 'file_change' | 'file_creation_start' | 'file_creation_input' | 'file_creation_cancel' | 'file_rename_start' | 'file_rename_input' | 'file_rename_cancel' | 'folder_toggle' | 'cursor_move' | 'cursor_click' | 'cursor_enter' | 'cursor_leave' | 'file_hover' | 'text_select' | 'editor_cursor' | 'tool_switch' | 'tool' | 'marker' | 'webcam_state' | 'content_dimensions';
+type CTEventType = 'init' | 'code' | 'code_edit' | 'language' | 'terminal' | 'terminal_input' | 'stroke_start' | 'whiteboard_points' | 'stroke_end' | 'whiteboard_stroke' | 'whiteboard_clear' | 'whiteboard_undo' | 'whiteboard' | 'whiteboard_point' | 'excalidraw_scene' | 'excalidraw_clear' | 'excalidraw_pointer' | 'overlay_scene' | 'overlay_clear' | 'overlay_pointer' | 'document_load' | 'document_page' | 'document_zoom' | 'document_scroll' | 'document_clear' | 'db_seed' | 'db_query' | 'db_result' | 'db_error' | 'db_schema_change' | 'db_snapshot' | 'file_create' | 'file_update' | 'file_delete' | 'file_rename' | 'file_switch' | 'folder_create' | 'folder_delete' | 'file_select' | 'file_change' | 'file_creation_start' | 'file_creation_input' | 'file_creation_cancel' | 'file_rename_start' | 'file_rename_input' | 'file_rename_cancel' | 'folder_toggle' | 'cursor_move' | 'cursor_click' | 'cursor_enter' | 'cursor_leave' | 'file_hover' | 'text_select' | 'editor_cursor' | 'editor_scroll' | 'tool_switch' | 'tool' | 'marker' | 'webcam_state' | 'content_dimensions' | 'panel_resize';
 /**
  * Base event structure with generic type parameter
  */
@@ -27,7 +27,7 @@ interface CTEventBase<T extends CTEventType = CTEventType> {
  * Discriminated union of all event types.
  * This enables proper type narrowing in switch statements.
  */
-type CTEvent = CTEventBase<'init'> | CTEventBase<'code'> | CTEventBase<'code_edit'> | CTEventBase<'language'> | CTEventBase<'terminal'> | CTEventBase<'terminal_input'> | CTEventBase<'stroke_start'> | CTEventBase<'whiteboard_points'> | CTEventBase<'stroke_end'> | CTEventBase<'whiteboard_stroke'> | CTEventBase<'whiteboard_clear'> | CTEventBase<'whiteboard_undo'> | CTEventBase<'whiteboard'> | CTEventBase<'whiteboard_point'> | CTEventBase<'excalidraw_scene'> | CTEventBase<'excalidraw_clear'> | CTEventBase<'excalidraw_pointer'> | CTEventBase<'overlay_scene'> | CTEventBase<'overlay_clear'> | CTEventBase<'overlay_pointer'> | CTEventBase<'document_load'> | CTEventBase<'document_page'> | CTEventBase<'document_zoom'> | CTEventBase<'document_scroll'> | CTEventBase<'document_clear'> | CTEventBase<'file_create'> | CTEventBase<'file_update'> | CTEventBase<'file_delete'> | CTEventBase<'file_rename'> | CTEventBase<'file_switch'> | CTEventBase<'folder_create'> | CTEventBase<'folder_delete'> | CTEventBase<'file_select'> | CTEventBase<'file_change'> | CTEventBase<'file_creation_start'> | CTEventBase<'file_creation_input'> | CTEventBase<'file_creation_cancel'> | CTEventBase<'file_rename_start'> | CTEventBase<'file_rename_input'> | CTEventBase<'file_rename_cancel'> | CTEventBase<'folder_toggle'> | CTEventBase<'cursor_move'> | CTEventBase<'cursor_click'> | CTEventBase<'cursor_enter'> | CTEventBase<'cursor_leave'> | CTEventBase<'file_hover'> | CTEventBase<'text_select'> | CTEventBase<'editor_cursor'> | CTEventBase<'tool_switch'> | CTEventBase<'tool'> | CTEventBase<'marker'> | CTEventBase<'webcam_state'> | CTEventBase<'content_dimensions'>;
+type CTEvent = CTEventBase<'init'> | CTEventBase<'code'> | CTEventBase<'code_edit'> | CTEventBase<'language'> | CTEventBase<'terminal'> | CTEventBase<'terminal_input'> | CTEventBase<'stroke_start'> | CTEventBase<'whiteboard_points'> | CTEventBase<'stroke_end'> | CTEventBase<'whiteboard_stroke'> | CTEventBase<'whiteboard_clear'> | CTEventBase<'whiteboard_undo'> | CTEventBase<'whiteboard'> | CTEventBase<'whiteboard_point'> | CTEventBase<'excalidraw_scene'> | CTEventBase<'excalidraw_clear'> | CTEventBase<'excalidraw_pointer'> | CTEventBase<'overlay_scene'> | CTEventBase<'overlay_clear'> | CTEventBase<'overlay_pointer'> | CTEventBase<'document_load'> | CTEventBase<'document_page'> | CTEventBase<'document_zoom'> | CTEventBase<'document_scroll'> | CTEventBase<'document_clear'> | CTEventBase<'db_seed'> | CTEventBase<'db_query'> | CTEventBase<'db_result'> | CTEventBase<'db_error'> | CTEventBase<'db_schema_change'> | CTEventBase<'db_snapshot'> | CTEventBase<'file_create'> | CTEventBase<'file_update'> | CTEventBase<'file_delete'> | CTEventBase<'file_rename'> | CTEventBase<'file_switch'> | CTEventBase<'folder_create'> | CTEventBase<'folder_delete'> | CTEventBase<'file_select'> | CTEventBase<'file_change'> | CTEventBase<'file_creation_start'> | CTEventBase<'file_creation_input'> | CTEventBase<'file_creation_cancel'> | CTEventBase<'file_rename_start'> | CTEventBase<'file_rename_input'> | CTEventBase<'file_rename_cancel'> | CTEventBase<'folder_toggle'> | CTEventBase<'cursor_move'> | CTEventBase<'cursor_click'> | CTEventBase<'cursor_enter'> | CTEventBase<'cursor_leave'> | CTEventBase<'file_hover'> | CTEventBase<'text_select'> | CTEventBase<'editor_cursor'> | CTEventBase<'editor_scroll'> | CTEventBase<'tool_switch'> | CTEventBase<'tool'> | CTEventBase<'marker'> | CTEventBase<'webcam_state'> | CTEventBase<'content_dimensions'> | CTEventBase<'panel_resize'>;
 /**
  * Mapping of event types to their data structures
  */
@@ -55,6 +55,12 @@ interface CTEventDataMap {
     document_zoom: DocumentZoomEventData;
     document_scroll: DocumentScrollEventData;
     document_clear: DocumentClearEventData;
+    db_seed: DbSeedEventData;
+    db_query: DbQueryEventData;
+    db_result: DbResultEventData;
+    db_error: DbErrorEventData;
+    db_schema_change: DbSchemaChangeEventData;
+    db_snapshot: DbSnapshotEventData;
     file_create: FileCreateEventData;
     file_update: FileUpdateEventData;
     file_delete: FileDeleteEventData;
@@ -76,10 +82,12 @@ interface CTEventDataMap {
     file_hover: FileHoverEventData;
     text_select: TextSelectEventData;
     editor_cursor: EditorCursorEventData;
+    editor_scroll: EditorScrollEventData;
     tool_switch: ToolSwitchEventData;
     marker: MarkerEventData;
     webcam_state: WebcamStateEventData;
     content_dimensions: ContentDimensionsEventData;
+    panel_resize: PanelResizeEventData;
     tool: ToolEventData;
     whiteboard: WhiteboardEventData;
     whiteboard_point: WhiteboardPointEventData;
@@ -231,6 +239,8 @@ interface InitEventData {
         width: number;
         height: number;
     };
+    dbSeedSql?: string;
+    dbSnapshot?: string;
 }
 /**
  * Code content change
@@ -434,6 +444,65 @@ interface DocumentScrollEventData {
  */
 interface DocumentClearEventData {
 }
+/**
+ * Instructor loads seed SQL (CREATE TABLE + INSERT).
+ * Fired once at the start of a DB session.
+ */
+interface DbSeedEventData {
+    /** The seed SQL text */
+    sql: string;
+    /** List of table names created by the seed */
+    tables: string[];
+}
+/**
+ * A SQL query was executed (instructor or student).
+ */
+interface DbQueryEventData {
+    /** The raw SQL string that was executed */
+    sql: string;
+}
+/**
+ * The result of a successfully executed query.
+ */
+interface DbResultEventData {
+    /** Column headers */
+    columns: string[];
+    /** Row data — each inner array is one row, values are primitives */
+    rows: (string | number | null)[][];
+    /** Total rows returned */
+    rowCount: number;
+    /** Wall-clock execution time in milliseconds */
+    executionTimeMs: number;
+}
+/**
+ * A query failed.
+ */
+interface DbErrorEventData {
+    /** The query that failed */
+    sql: string;
+    /** The error message */
+    message: string;
+}
+/**
+ * The schema changed (after DDL). Contains current schema state.
+ */
+interface DbSchemaChangeEventData {
+    /** Current schema — output of SELECT name, sql FROM sqlite_master */
+    tables: {
+        name: string;
+        sql: string;
+    }[];
+}
+/**
+ * Full database binary snapshot (base64-encoded).
+ * Used for seeking.
+ */
+interface DbSnapshotEventData {
+    /** The full database serialized as a base64 string */
+    snapshot: string;
+    /** Current table names for quick reference */
+    tables: string[];
+}
 /**
  * Create new file
  */
@@ -594,6 +663,13 @@ interface EditorCursorEventData {
     /** Column number (1-based) */
     column: number;
 }
+/**
+ * Editor scroll position (code editor)
+ */
+interface EditorScrollEventData {
+    /** Vertical scroll offset in pixels */
+    scrollTop: number;
+}
 /**
  * Switch active tool
  */
@@ -623,6 +699,15 @@ interface ContentDimensionsEventData {
     width: number;
     height: number;
 }
+/**
+ * Panel resize event — captures explorer width and terminal height changes
+ */
+interface PanelResizeEventData {
+    /** Which panel was resized */
+    panel: 'explorer' | 'terminal';
+    /** New size in pixels (width for explorer, height for terminal) */
+    size: number;
+}
 /**
  * Legacy tool event (same as tool_switch)
  */
@@ -704,6 +789,7 @@ interface PlaybackState$1 {
         y: number;
         visible: boolean;
         clicking?: boolean;
+        clickTimestamp?: number;
     };
     /** File creation UI state - for showing inline input during playback */
     fileCreation: FileCreationState | null;
@@ -717,6 +803,8 @@ interface PlaybackState$1 {
     textSelection: TextSelectionState | null;
     /** Editor typing cursor (caret) position */
     editorCursor: EditorCursorState | null;
+    /** Editor scroll position (pixels from top) */
+    editorScrollTop: number;
     /** Whether webcam is in maximized (full overlay) mode */
     webcamMaximized: boolean;
     /** Content area dimensions from the recording session.
@@ -743,6 +831,32 @@ interface PlaybackState$1 {
         tool: 'pointer' | 'laser';
         button: 'down' | 'up';
     } | null;
+    /** Whether a sql.js database is active in this recording */
+    dbInitialized: boolean;
+    /** The seed SQL that was loaded (null if no DB session) */
+    dbSeedSql: string | null;
+    /** The most recently executed SQL query */
+    dbLastQuery: string | null;
+    /** The most recently returned query result */
+    dbLastResult: DbResultEventData | null;
+    /** The most recent error message (null if last query succeeded) */
+    dbLastError: string | null;
+    /** Current schema (tables + their CREATE statements) */
+    dbSchema: {
+        name: string;
+        sql: string;
+    }[];
+    /** Most recent base64 snapshot (for seeking) */
+    dbSnapshot: string | null;
+    /** History of queries executed so far (for query history panel) */
+    dbQueryHistory: {
+        sql: string;
+        time: number;
+    }[];
+    /** File explorer panel width in pixels (null = use default) */
+    explorerWidth: number | null;
+    /** Terminal panel height in pixels (null = use default) */
+    terminalHeight: number | null;
 }
 /**
  * State for file/folder creation UI display during playback
@@ -1614,6 +1728,10 @@ interface IDEPanelProps extends BasePanelProps {
         line: number;
         column: number;
     }) => void;
+    /** Editor scroll position in pixels from top (playback display) */
+    editorScrollTop?: number;
+    /** Editor scroll change callback (recording) */
+    onEditorScrollChange?: (scrollTop: number) => void;
     /**
      * Called when user interacts with the IDE (clicks explorer, terminal, etc).
      * Use this to pause playback when user starts interacting.
@@ -1629,6 +1747,41 @@ interface IDEPanelProps extends BasePanelProps {
     aiDebugEnabled?: boolean;
     /** API endpoint for AI debug analysis. Default: '/api/ai/debug' */
     aiDebugEndpoint?: string;
+    /** Whether a sql.js database is active in this recording */
+    dbInitialized?: boolean;
+    /** Current database schema */
+    dbSchema?: {
+        name: string;
+        sql: string;
+    }[];
+    /** Most recently executed SQL query */
+    dbLastQuery?: string | null;
+    /** Most recent query result */
+    dbLastResult?: {
+        columns: string[];
+        rows: (string | number | null)[][];
+        rowCount: number;
+        executionTimeMs: number;
+    } | null;
+    /** Most recent error message */
+    dbLastError?: string | null;
+    /** Query execution history */
+    dbQueryHistory?: {
+        sql: string;
+        time: number;
+    }[];
+    /** Execute a SQL query (recording/interactive) */
+    onDbQueryExecute?: (sql: string) => void | Promise<void>;
+    /** Load seed SQL (recording) */
+    onDbSeedLoad?: (sql: string) => void | Promise<void>;
+    /** Reset database (recording) */
+    onDbReset?: () => void;
+    /** External explorer width (for playback — overrides local state) */
+    explorerWidthState?: number | null;
+    /** External terminal height (for playback — overrides local state) */
+    terminalHeightState?: number | null;
+    /** Called when a panel is resized (for recording) */
+    onPanelResize?: (panel: 'explorer' | 'terminal', size: number) => void;
 }
 /**
  * Excalidraw scene structure (simplified)
@@ -1882,7 +2035,7 @@ interface VirtualFileSystem {
     notifyChanged?: () => void;
     mkdir?: (path: string) => void;
 }
-declare function IDEPanel({ fileSystem, tree: externalTree, files: externalFiles, code: externalCode, language: externalLanguage, currentFile: externalCurrentFile, onCodeChange, onFileChange, onFileCreate, onFileDelete, onFileRename, onFileSelect, onFolderCreate, onFolderDelete, onTerminalCommand, onTerminalClear, onTerminalAddLines, fileCreationState, onFileCreationStart, onFileCreationInput, onFileCreationCancel, fileRenamingState, onFileRenameStart, onFileRenameInput, onFileRenameCancel, expandedFoldersState, onFolderToggle, terminalLines: externalTerminalLines, terminalInput: externalTerminalInput, onTerminalInputChange, onExecute, onTerminalExecute, mode, isPlaying, defaultShowExplorer, defaultShowTerminal, showRunButton, interactiveLabel, initialFiles, initialActiveFile, hoveredFile, onFileHover, textSelection, onTextSelect, editorCursor, onEditorCursorChange, onInteractionStart, aiSuggestionsEnabled, aiSuggestionsEndpoint, aiSuggestionsDebounceMs, aiDebugEnabled, aiDebugEndpoint, }: IDEPanelProps & {
+declare function IDEPanel({ fileSystem, tree: externalTree, files: externalFiles, code: externalCode, language: externalLanguage, currentFile: externalCurrentFile, onCodeChange, onFileChange, onFileCreate, onFileDelete, onFileRename, onFileSelect, onFolderCreate, onFolderDelete, onTerminalCommand, onTerminalClear, onTerminalAddLines, fileCreationState, onFileCreationStart, onFileCreationInput, onFileCreationCancel, fileRenamingState, onFileRenameStart, onFileRenameInput, onFileRenameCancel, expandedFoldersState, onFolderToggle, terminalLines: externalTerminalLines, terminalInput: externalTerminalInput, onTerminalInputChange, onExecute, onTerminalExecute, mode, isPlaying, defaultShowExplorer, defaultShowTerminal, showRunButton, interactiveLabel, initialFiles, initialActiveFile, hoveredFile, onFileHover, textSelection, onTextSelect, editorCursor, onEditorCursorChange, editorScrollTop, onEditorScrollChange, onInteractionStart, aiSuggestionsEnabled, aiSuggestionsEndpoint, aiSuggestionsDebounceMs, aiDebugEnabled, aiDebugEndpoint, dbInitialized, dbSchema, dbLastQuery, dbLastResult, dbLastError, dbQueryHistory, onDbQueryExecute, onDbSeedLoad, onDbReset, explorerWidthState, terminalHeightState, onPanelResize, }: IDEPanelProps & {
     fileSystem?: VirtualFileSystem;
 }): react_jsx_runtime.JSX.Element;
 
@@ -1891,52 +2044,100 @@ declare function FileExplorer({ tree, selectedFile, expandedFolders, fileCreatio
 declare const Terminal: React__default.ForwardRefExoticComponent<TerminalProps & React__default.RefAttributes<TerminalRef>>;
 
 /**
- * Learner Branch Types
+ * PlaybackStateMachine
  *
- * A branch is a saved snapshot of the learner's code edits at a specific
- * moment in the instructor's timeline. Branches are learner-side only —
- * they never modify the .ct file, events, or manifest.
+ * Pure TypeScript finite state machine for player state management.
+ * No React, no DOM, no side effects — only state and transitions.
+ *
+ * Replaces the 13 booleans scattered across useRemoteStreamingPlayback
+ * with a single enum value and enforced valid transitions.
  *
  * @packageDocumentation
  */
-/**
- * A point-in-time capture of the IDE state.
- * Used for both the instructor's original state and the learner's edited state.
- */
-interface BranchSnapshot {
-    /** Active file's code content */
-    code: string;
-    /** Programming language at snapshot time */
-    language: string;
-    /** Which file tab was active (null if single-file mode) */
-    currentFile: string | null;
-    /** Full file system snapshot — path → content */
-    fileSystem: Record<string, string>;
-    /** Terminal output lines if any existed */
-    terminalOutput?: string[];
-    /** Which tool panel was open (code / terminal / whiteboard / document) */
-    activeTool: string;
-    /** Folder paths created by the learner during interactive mode */
-    folders?: string[];
+type PlayerState = 'IDLE' | 'LOADING' | 'READY' | 'PLAYING' | 'PAUSED' | 'BUFFERING' | 'SEEKING' | 'ENDED' | 'ERROR';
+type PlayerAction = 'LOAD' | 'SOURCES_READY' | 'PLAY' | 'PAUSE' | 'BUFFER_EMPTY' | 'BUFFER_READY' | 'SEEK' | 'SEEK_COMPLETE' | 'COMPLETE' | 'ERROR' | 'RESET' | 'DESTROY';
+interface Transition {
+    from: PlayerState;
+    to: PlayerState;
+    action: PlayerAction;
+}
+type TransitionListener = (transition: Transition) => void;
+declare class PlaybackStateMachine {
+    private _state;
+    private _listeners;
+    private _preSeekState;
+    private _destroyed;
+    get state(): PlayerState;
+    get preSeekState(): PlayerState | null;
+    /**
+     * Dispatch an action. Returns true if the transition was valid, false otherwise.
+     * Invalid transitions are logged as warnings — they are programmer errors.
+     */
+    dispatch(action: PlayerAction): boolean;
+    /**
+     * Subscribe to state transitions. Returns an unsubscribe function.
+     */
+    onTransition(fn: TransitionListener): () => void;
+    /**
+     * Check if the current state is one of the given states.
+     */
+    is(...states: PlayerState[]): boolean;
 }
+
 /**
- * A learner branch — a saved code snapshot at a point in the timeline.
+ * MasterClock
+ *
+ * The single source of time for the entire player. Nothing else reads
+ * `audio.currentTime` directly — everything goes through this clock.
+ *
+ * Two tick sources work together:
+ * 1. `timeupdate` event (primary) — fires ~4x/sec from audio element.
+ *    Reliable in background tabs. Source of truth for "what time is it."
+ * 2. `requestAnimationFrame` (interpolation) — fires ~60fps when visible.
+ *    Between timeupdate ticks, interpolates linearly for smooth UI.
+ *
+ * No React, no DOM ownership — pure TypeScript.
+ *
+ * @packageDocumentation
  */
-interface LearnerBranch {
-    /** Unique branch ID (crypto.randomUUID) */
-    id: string;
-    /** Lesson/recording this branch belongs to */
-    lessonId: string;
-    /** Playback time in milliseconds where the learner paused */
-    timeMs: number;
-    /** Instructor's state at that moment (for comparison / restoring) */
-    originalState: BranchSnapshot;
-    /** Learner's edited state */
-    learnerState: BranchSnapshot;
-    /** ISO timestamp of when the branch was created */
-    createdAt: string;
-    /** User-provided label, defaults to "Branch at MM:SS" */
-    label?: string;
+type ClockTickCallback = (timeMs: number) => void;
+interface ClockSource {
+    getCurrentTimeMs(): number;
+    onTick(fn: ClockTickCallback): () => void;
+    setPlaybackRate(rate: number): void;
+    getPlaybackRate(): number;
+}
+declare class MasterClock {
+    private source;
+    private sourceUnsub;
+    private subscribers;
+    private rafId;
+    private lastTickTimeMs;
+    private lastTickTimestamp;
+    private playbackRate;
+    private running;
+    /** Attach a clock source (e.g., audio element wrapper). */
+    setSource(source: ClockSource): void;
+    /**
+     * Get current time in ms.
+     * Between timeupdate ticks, interpolates linearly using elapsed wall-clock time.
+     */
+    getCurrentTimeMs(): number;
+    /** Start the RAF interpolation loop for smooth UI updates. */
+    start(): void;
+    /** Stop the RAF loop. timeupdate events still arrive from the source. */
+    stop(): void;
+    /** Subscribe to clock ticks (called on every RAF frame + every timeupdate). */
+    subscribe(fn: ClockTickCallback): () => void;
+    setPlaybackRate(rate: number): void;
+    getPlaybackRate(): number;
+    /** Force-set the clock position (used after seek). */
+    seekTo(timeMs: number): void;
+    /** Whether the RAF loop is running. */
+    isRunning(): boolean;
+    private rafLoop;
+    private notify;
+    destroy(): void;
 }
 
 /**
@@ -2090,33 +2291,6 @@ interface StreamingManifest {
      */
     interactionPoints?: InteractionPointManifest[];
 }
-/**
- * Options for useRemoteStreamingPlayback hook
- */
-interface UseRemoteStreamingPlaybackOptions {
-    /** URL to the streaming manifest.json */
-    manifestUrl: string;
-    /** Auto-play when ready */
-    autoPlay?: boolean;
-    /** Initial playback speed (default: 1.0) */
-    defaultSpeed?: number;
-    /** Maximum chunks to keep in memory (default: 5) */
-    maxCacheSize?: number;
-    /** Called when streaming is ready to play */
-    onReady?: () => void;
-    /** Called when playback starts */
-    onPlay?: () => void;
-    /** Called when playback pauses */
-    onPause?: () => void;
-    /** Called on playback progress */
-    onProgress?: (timeMs: number, duration: number) => void;
-    /** Called when playback completes */
-    onComplete?: () => void;
-    /** Called when buffering state changes */
-    onBuffering?: (isBuffering: boolean) => void;
-    /** Called on error */
-    onError?: (error: Error) => void;
-}
 /**
  * Buffer health status for remote streaming
  */
@@ -2132,77 +2306,6 @@ interface RemoteBufferHealth {
     /** Total buffered time in milliseconds */
     bufferedTimeMs: number;
 }
-/**
- * Performance metrics for remote streaming
- */
-interface RemoteStreamingMetrics {
-    /** Average chunk fetch time in ms */
-    avgChunkFetchTimeMs: number;
-    /** Cache hit rate (0-1) */
-    cacheHitRate: number;
-    /** Number of times playback had to wait for buffering */
-    bufferUnderrunCount: number;
-    /** Average seek time in ms */
-    avgSeekTimeMs: number;
-    /** Total bytes downloaded */
-    totalBytesLoaded: number;
-    /** Peak number of chunks in cache */
-    peakChunksCached: number;
-}
-/**
- * Complete state returned by the remote streaming hook
- */
-interface RemoteStreamingPlaybackState {
-    /** Current playback state (code, terminal, etc.) */
-    state: PlaybackState$1;
-    /** Current playback time in milliseconds */
-    currentTime: number;
-    /** Total duration in milliseconds */
-    duration: number;
-    /** Whether playback is active */
-    isPlaying: boolean;
-    /** Current playback speed */
-    speed: number;
-    /** Whether the player is ready (UI can render — audio+events loaded) */
-    isReady: boolean;
-    /** Whether ALL sources are loaded and synced (audio+video+events) */
-    allSourcesReady: boolean;
-    /** Whether currently buffering */
-    isBuffering: boolean;
-    /** Buffer health information */
-    bufferHealth: RemoteBufferHealth;
-    /** Streaming metrics */
-    metrics: RemoteStreamingMetrics;
-    /** Current error (if any) */
-    error: Error | null;
-    /** The loaded manifest */
-    manifest: StreamingManifest | null;
-}
-/**
- * Controls for remote streaming playback
- */
-interface RemoteStreamingPlaybackControls {
-    /** Start playback */
-    play(): void;
-    /** Pause playback */
-    pause(): void;
-    /** Seek to a specific time (milliseconds) */
-    seek(timeMs: number): Promise<void>;
-    /** Set playback speed */
-    setSpeed(speed: number): void;
-    /** Get the audio element for custom controls */
-    getAudioElement(): HTMLAudioElement | null;
-    /** Get the video element for webcam overlay (null if no video) */
-    getVideoElement(): HTMLVideoElement | null;
-    /** Attach HLS video player to a video element (from WebcamOverlay onVideoRef) */
-    initVideoHls(videoElement: HTMLVideoElement | null): void;
-    /** Get available webcam video quality levels */
-    getVideoQualityLevels(): HLSQualityLevel[];
-    /** Set webcam video quality level (-1 for auto) */
-    setVideoQualityLevel(index: number): void;
-    /** Get current webcam video quality level (-1 = auto) */
-    getVideoQualityLevel(): number;
-}
 /**
  * HLS player configuration
  */
@@ -2215,6 +2318,8 @@ interface HLSPlayerConfig {
     startLevel?: number;
     /** Auto-start load */
     autoStartLoad?: boolean;
+    /** Cap quality level to the video element's display dimensions */
+    capLevelToPlayerSize?: boolean;
 }
 /**
  * HLS quality level info
@@ -2233,96 +2338,579 @@ interface HLSQualityLevel {
 }
 
 /**
- * @ct-courses/player - Type Definitions
+ * Remote Chunk Fetcher
+ *
+ * Handles fetching and decompressing event chunks from CDN.
+ * Supports gzip compressed chunks and provides retry logic.
+ *
+ * @packageDocumentation
  */
 
-/**
- * Backend adapter interface for loading recordings
- */
-interface BackendAdapter {
-    getRecording(id: string): Promise<InternalRecording | null>;
-    getMediaUrl?(recordingId: string): Promise<string | null>;
-}
-/**
- * Internal recording structure (from backend)
- */
-interface InternalRecording {
-    id: string;
-    name?: string;
-    duration: number;
-    events: InternalEvent[];
-    markers?: RecordingMarker[];
-    hasMedia?: boolean;
-    mediaUrl?: string;
-    createdAt?: number;
-}
-/**
- * Internal event structure (from backend)
- */
-interface InternalEvent {
-    type: string;
-    time: number;
-    data: Record<string, unknown>;
+interface FetchResult<T> {
+    data: T | null;
+    error: string | null;
+    durationMs: number;
+    bytesLoaded: number;
 }
-/**
- * Recording marker for chapters
- */
-interface RecordingMarker {
-    id: string;
-    time: number;
-    label: string;
-    color?: string;
+interface ChunkFetchResult extends FetchResult<CTEventChunk> {
+    chunkId: number;
 }
-/**
- * Cursor position for replay
- */
-interface CursorPosition {
-    x: number;
-    y: number;
-    visible: boolean;
+interface FetcherConfig {
+    /** Maximum retry attempts */
+    maxRetries: number;
+    /** Base delay between retries (ms) */
+    retryDelayMs: number;
+    /** Request timeout (ms) */
+    timeoutMs: number;
+}
+/**
+ * Fetcher for streaming manifest and event chunks
+ */
+declare class ChunkFetcher {
+    private config;
+    private chunkIndex;
+    private eventsBaseUrl;
+    private compressed;
+    private pendingFetches;
+    private abortController;
+    private metrics;
+    constructor(config?: Partial<FetcherConfig>);
+    /**
+     * Fetch the streaming manifest
+     */
+    fetchManifest(manifestUrl: string): Promise<FetchResult<StreamingManifest>>;
+    /**
+     * Fetch the events chunk index
+     */
+    fetchChunkIndex(indexUrl: string): Promise<FetchResult<CTEventChunkIndex>>;
+    /**
+     * Initialize the fetcher with a manifest
+     */
+    initialize(manifest: StreamingManifest, chunkIndex: CTEventChunkIndex): void;
+    /**
+     * Fetch a specific chunk by ID
+     */
+    fetchChunk(chunkId: number): Promise<ChunkFetchResult>;
+    /**
+     * Prefetch multiple chunks
+     */
+    prefetchChunks(chunkIds: number[]): Promise<void>;
+    /**
+     * Get fetcher metrics
+     */
+    getMetrics(): {
+        totalFetches: number;
+        totalBytes: number;
+        avgFetchTimeMs: number;
+        errorRate: number;
+    };
+    /**
+     * Get chunk info by ID
+     */
+    getChunkInfo(chunkId: number): CTChunkInfo | null;
+    /**
+     * Get total chunk count
+     */
+    getTotalChunks(): number;
+    /**
+     * Reset fetcher state
+     */
+    reset(): void;
 }
+
 /**
- * File system snapshot
+ * MediaSourceAdapter — Interface for pluggable media sources.
+ *
+ * Abstracts how the PlayerEngine obtains audio, video, and event data.
+ * Implementations:
+ *   - HlsStreamingAdapter: CDN/HLS streaming via manifest URL
+ *   - LocalFileAdapter: Local .ct file playback from a CTRecording blob
+ *
+ * @packageDocumentation
  */
-interface FileSystemSnapshot {
-    [path: string]: string;
+
+type AudioSourceResult = {
+    type: 'hls';
+    url: string;
+} | {
+    type: 'url';
+    url: string;
+};
+type VideoSourceResult = {
+    type: 'hls';
+    url: string;
+} | {
+    type: 'url';
+    url: string;
+} | null;
+type EventsSourceResult = {
+    type: 'chunked';
+    manifestUrl: string;
+} | {
+    type: 'inline';
+    events: CTEvent[];
+    duration: number;
+};
+interface RecordingInfo {
+    duration: number;
+    name?: string;
+    hasVideo: boolean;
+}
+interface MediaSourceAdapter {
+    /** Get the audio source configuration */
+    getAudioSource(): Promise<AudioSourceResult>;
+    /** Get the events source configuration */
+    getEventsSource(): Promise<EventsSourceResult>;
+    /** Get basic recording metadata */
+    getRecordingInfo(): RecordingInfo;
+    /** Get the video source configuration (null if no video) */
+    getVideoSource(): Promise<VideoSourceResult>;
+    /** Get the streaming manifest (only available for chunked sources) */
+    getManifest(): StreamingManifest | null;
+    /** Cleanup any resources (e.g., revoke blob URLs) */
+    dispose(): void;
 }
+
 /**
- * Document data with content (extends DocumentInfo with raw data)
+ * Engine-only types — no React dependencies.
+ *
+ * @packageDocumentation
  */
-interface PlayerDocumentData extends DocumentInfo {
-    /** Raw document data (base64 for PDFs, etc.) */
-    data: string;
-}
+
 /**
- * Playback engine configuration
+ * Configuration for creating a PlayerEngine instance.
+ * No React types — this is framework-agnostic.
  */
-interface PlaybackEngineConfig {
-    /** Recording ID to load */
-    recordingId?: string;
-    /** Backend adapter for loading */
-    backendAdapter?: BackendAdapter;
-    /** Pre-loaded recording */
-    recording?: InternalRecording;
-    /** CT file blob to load */
-    ctFile?: Blob;
-    /** Auto-play on load */
+interface PlayerEngineConfig {
+    /** URL to the streaming manifest.json (used for HLS streaming) */
+    manifestUrl?: string;
+    /** Pluggable media source adapter (takes precedence over manifestUrl) */
+    source?: MediaSourceAdapter;
+    /** Unique content ID for resume position storage (defaults to manifestUrl hash) */
+    contentId?: string;
+    /** Auto-play when ready */
     autoPlay?: boolean;
-    /** Initial playback speed */
-    initialSpeed?: number;
-    /** Initial volume (0-1) */
-    initialVolume?: number;
+    /** Initial playback speed (default: 1.0) */
+    defaultSpeed?: number;
+    /** Maximum chunks to keep in memory (default: 10) */
+    maxCacheSize?: number;
     onReady?: () => void;
     onPlay?: () => void;
     onPause?: () => void;
-    onEnded?: () => void;
-    onTimeUpdate?: (time: number) => void;
+    onProgress?: (timeMs: number, duration: number) => void;
+    onComplete?: () => void;
+    onBuffering?: (isBuffering: boolean) => void;
     onError?: (error: Error) => void;
 }
 /**
- * Playback engine state
+ * Immutable snapshot of the entire player state.
+ * React subscribes to this via `onSnapshot()`.
+ *
+ * One object instead of 12 separate useState calls.
+ * Pattern used by Zustand, Redux, XState, TanStack Query.
  */
-interface PlaybackState {
+interface PlayerSnapshot {
+    /** Current state machine state */
+    machineState: PlayerState;
+    /** Current playback state (code, terminal, whiteboard, etc.) */
+    playbackState: PlaybackState$1;
+    /** Current playback time in milliseconds */
+    currentTime: number;
+    /** Total duration in milliseconds */
+    duration: number;
+    /** Current playback speed */
+    speed: number;
+    /** Buffer health information */
+    bufferHealth: RemoteBufferHealth;
+    /** Current error (if any) */
+    error: Error | null;
+    /** The loaded manifest */
+    manifest: StreamingManifest | null;
+    /** Saved resume position in ms (null if none or past 95%) */
+    resumePosition: number | null;
+    /** Whether playback is active (derived from machineState) */
+    isPlaying: boolean;
+    /** Whether the player is ready (audio + events loaded, UI can render) */
+    isReady: boolean;
+    /** Whether ALL sources are loaded and synced (audio + video + events) */
+    allSourcesReady: boolean;
+    /** Whether currently buffering */
+    isBuffering: boolean;
+}
+
+type SnapshotListener = (snapshot: PlayerSnapshot) => void;
+declare class PlayerEngine {
+    private machine;
+    private clock;
+    private scheduler;
+    private media;
+    private buffer;
+    private config;
+    private resumeKey;
+    private sourceAdapter;
+    private _snapshot;
+    private _listeners;
+    private _lastTimeEmitTs;
+    private audioElement;
+    private videoElement;
+    private _destroyed;
+    private audioReady;
+    private eventsReady;
+    private videoReady;
+    private hasVideo;
+    private pendingPlay;
+    private seekGeneration;
+    private lastBufferHealthCheckTs;
+    private bufferingDebounceTimer;
+    private videoListenersCleanup;
+    private clockUnsub;
+    private schedulerUnsub;
+    private machineUnsub;
+    private audioListenersCleanup;
+    private tickActive;
+    constructor(config: PlayerEngineConfig);
+    /**
+     * Load media and events via the configured source adapter.
+     * Supports both HLS streaming (chunked) and local file (inline) sources.
+     * Transitions: IDLE → LOADING → READY (or ERROR).
+     */
+    load(): Promise<void>;
+    /**
+     * Start playback. Gates on allSourcesReady.
+     */
+    play(): void;
+    /**
+     * Pause playback.
+     */
+    pause(): void;
+    /**
+     * Seek to a specific time in milliseconds.
+     */
+    seek(timeMs: number): Promise<void>;
+    /**
+     * Set playback speed.
+     */
+    setSpeed(speed: number): void;
+    /**
+     * Set volume level (0–2+, values > 1 amplify via Web Audio).
+     */
+    setVolume(level: number): void;
+    /**
+     * Set muted state (uses GainNode, not audio.muted).
+     */
+    setMuted(muted: boolean): void;
+    /**
+     * Initialize video for a given video element.
+     * Supports both HLS (streaming) and direct URL (local file) sources.
+     * Called from React when the <video> element mounts.
+     */
+    initVideo(element: HTMLVideoElement | null): Promise<void>;
+    /**
+     * Toggle webcam visibility — NEVER destroys HLS.
+     */
+    setVideoVisible(visible: boolean): void;
+    getVideoQualityLevels(): HLSQualityLevel[];
+    setVideoQualityLevel(index: number): void;
+    getVideoQualityLevel(): number;
+    getAudioElement(): HTMLAudioElement | null;
+    getVideoElement(): HTMLVideoElement | null;
+    /**
+     * Get buffer/fetch metrics for diagnostics (polled by hook for metrics state).
+     */
+    getBufferMetrics(): {
+        avgFetchTimeMs: number;
+        cacheHitRate: number;
+        peakCache: number;
+        fetcherMetrics: ReturnType<ChunkFetcher["getMetrics"]>;
+    };
+    /**
+     * Get the source adapter (for adapter-specific operations like LocalFileAdapter.getRecording()).
+     */
+    getSourceAdapter(): MediaSourceAdapter | null;
+    /**
+     * Get the current snapshot.
+     */
+    getSnapshot(): PlayerSnapshot;
+    /**
+     * Subscribe to snapshot changes. Returns an unsubscribe function.
+     * Time-only updates are throttled to ~4/sec.
+     * State transitions emit immediately.
+     */
+    onSnapshot(fn: SnapshotListener): () => void;
+    resumeAudioContext(): void;
+    destroy(): void;
+    private handleTransition;
+    private handleSchedulerEvent;
+    private startTickLoop;
+    private stopTickLoop;
+    private wireAudioEvents;
+    private wireVideoEvents;
+    private cleanupVideoListeners;
+    private checkAllSourcesReady;
+    private syncVideoToClock;
+    private rebuildStateAtTime;
+    private waitForVideoSeek;
+    private loadResumePosition;
+    private saveResumePosition;
+    private clearBufferingDebounce;
+    /**
+     * Update snapshot and notify listeners.
+     * This is the ONLY way to mutate the snapshot.
+     */
+    private updateSnapshot;
+    private emitSnapshot;
+}
+
+/**
+ * usePlayerEngine — Thin React binding for PlayerEngine
+ *
+ * 1 ref, 1 state, 1 effect, 1 memo. That's the entire React layer.
+ * Replaces 65 refs, 120 effects from the old hooks.
+ *
+ * @packageDocumentation
+ */
+
+interface PlayerControls$1 {
+    play(): void;
+    pause(): void;
+    seek(timeMs: number): Promise<void>;
+    setSpeed(speed: number): void;
+    setVolume(level: number): void;
+    setMuted(muted: boolean): void;
+    setVideoVisible(visible: boolean): void;
+    initVideo(element: HTMLVideoElement | null): void;
+    getAudioElement(): HTMLAudioElement | null;
+    getVideoElement(): HTMLVideoElement | null;
+    getVideoQualityLevels(): HLSQualityLevel[];
+    setVideoQualityLevel(index: number): void;
+    getVideoQualityLevel(): number;
+    resumeAudioContext(): void;
+    getSourceAdapter(): MediaSourceAdapter | null;
+}
+interface UsePlayerEngineResult {
+    snapshot: PlayerSnapshot;
+    controls: PlayerControls$1;
+}
+declare function usePlayerEngine(config: PlayerEngineConfig): UsePlayerEngineResult;
+
+/**
+ * ErrorBoundary — catches render errors in the player component tree.
+ * Class component because React error boundaries require getDerivedStateFromError.
+ */
+
+interface ErrorBoundaryProps {
+    /** Fallback UI to render on error */
+    fallback: React__default__default.ReactNode | ((error: Error) => React__default__default.ReactNode);
+    /** Optional error callback */
+    onError?: (error: Error, errorInfo: React__default__default.ErrorInfo) => void;
+    children: React__default__default.ReactNode;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+declare class PlayerErrorBoundary extends React__default__default.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, info: React__default__default.ErrorInfo): void;
+    render(): React__default__default.ReactNode;
+}
+
+/**
+ * HlsStreamingAdapter — MediaSourceAdapter for CDN/HLS streaming.
+ *
+ * Wraps a manifest URL and provides HLS audio, chunked events,
+ * and (optionally) HLS video sources to the PlayerEngine.
+ *
+ * @packageDocumentation
+ */
+
+declare class HlsStreamingAdapter implements MediaSourceAdapter {
+    private manifestUrl;
+    private manifest;
+    constructor(manifestUrl: string);
+    /** Inject a pre-fetched manifest (avoids double fetch when engine already loaded it). */
+    setManifest(manifest: StreamingManifest): void;
+    private ensureManifest;
+    getAudioSource(): Promise<AudioSourceResult>;
+    getEventsSource(): Promise<EventsSourceResult>;
+    getRecordingInfo(): RecordingInfo;
+    getVideoSource(): Promise<VideoSourceResult>;
+    getManifest(): StreamingManifest | null;
+    dispose(): void;
+}
+
+/**
+ * LocalFileAdapter — MediaSourceAdapter for local .ct file playback.
+ *
+ * Wraps a CTRecording, exposing its mediaBlob as a blob-URL audio source
+ * and its events as inline events (no chunk fetching needed).
+ *
+ * @packageDocumentation
+ */
+
+declare class LocalFileAdapter implements MediaSourceAdapter {
+    private recording;
+    private blobUrl;
+    constructor(recording: CTRecording);
+    getAudioSource(): Promise<AudioSourceResult>;
+    getEventsSource(): Promise<EventsSourceResult>;
+    getRecordingInfo(): RecordingInfo;
+    getVideoSource(): Promise<VideoSourceResult>;
+    getManifest(): StreamingManifest | null;
+    /** Get the underlying recording for interactive mode features. */
+    getRecording(): CTRecording;
+    dispose(): void;
+}
+
+/**
+ * Learner Branch Types
+ *
+ * A branch is a saved snapshot of the learner's code edits at a specific
+ * moment in the instructor's timeline. Branches are learner-side only —
+ * they never modify the .ct file, events, or manifest.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A point-in-time capture of the IDE state.
+ * Used for both the instructor's original state and the learner's edited state.
+ */
+interface BranchSnapshot {
+    /** Active file's code content */
+    code: string;
+    /** Programming language at snapshot time */
+    language: string;
+    /** Which file tab was active (null if single-file mode) */
+    currentFile: string | null;
+    /** Full file system snapshot — path → content */
+    fileSystem: Record<string, string>;
+    /** Terminal output lines if any existed */
+    terminalOutput?: string[];
+    /** Which tool panel was open (code / terminal / whiteboard / document) */
+    activeTool: string;
+    /** Folder paths created by the learner during interactive mode */
+    folders?: string[];
+    /** Base64 snapshot of the sql.js database (learner's modified DB) */
+    dbSnapshot?: string;
+    /** The seed SQL used to initialize the database */
+    dbSeedSql?: string;
+    /** Current database schema at snapshot time */
+    dbSchema?: {
+        name: string;
+        sql: string;
+    }[];
+}
+/**
+ * A learner branch — a saved code snapshot at a point in the timeline.
+ */
+interface LearnerBranch {
+    /** Unique branch ID (crypto.randomUUID) */
+    id: string;
+    /** Lesson/recording this branch belongs to */
+    lessonId: string;
+    /** Playback time in milliseconds where the learner paused */
+    timeMs: number;
+    /** Instructor's state at that moment (for comparison / restoring) */
+    originalState: BranchSnapshot;
+    /** Learner's edited state */
+    learnerState: BranchSnapshot;
+    /** ISO timestamp of when the branch was created */
+    createdAt: string;
+    /** User-provided label, defaults to "Branch at MM:SS" */
+    label?: string;
+}
+
+/**
+ * @ct-courses/player - Type Definitions
+ */
+
+/**
+ * Backend adapter interface for loading recordings
+ */
+interface BackendAdapter {
+    getRecording(id: string): Promise<InternalRecording | null>;
+    getMediaUrl?(recordingId: string): Promise<string | null>;
+}
+/**
+ * Internal recording structure (from backend)
+ */
+interface InternalRecording {
+    id: string;
+    name?: string;
+    duration: number;
+    events: InternalEvent[];
+    markers?: RecordingMarker[];
+    hasMedia?: boolean;
+    mediaUrl?: string;
+    createdAt?: number;
+}
+/**
+ * Internal event structure (from backend)
+ */
+interface InternalEvent {
+    type: string;
+    time: number;
+    data: Record<string, unknown>;
+}
+/**
+ * Recording marker for chapters
+ */
+interface RecordingMarker {
+    id: string;
+    time: number;
+    label: string;
+    color?: string;
+}
+/**
+ * Cursor position for replay
+ */
+interface CursorPosition {
+    x: number;
+    y: number;
+    visible: boolean;
+}
+/**
+ * File system snapshot
+ */
+interface FileSystemSnapshot {
+    [path: string]: string;
+}
+/**
+ * Document data with content (extends DocumentInfo with raw data)
+ */
+interface PlayerDocumentData extends DocumentInfo {
+    /** Raw document data (base64 for PDFs, etc.) */
+    data: string;
+}
+/**
+ * Playback engine configuration
+ */
+interface PlaybackEngineConfig {
+    /** Recording ID to load */
+    recordingId?: string;
+    /** Backend adapter for loading */
+    backendAdapter?: BackendAdapter;
+    /** Pre-loaded recording */
+    recording?: InternalRecording;
+    /** CT file blob to load */
+    ctFile?: Blob;
+    /** Auto-play on load */
+    autoPlay?: boolean;
+    /** Initial playback speed */
+    initialSpeed?: number;
+    /** Initial volume (0-1) */
+    initialVolume?: number;
+    onReady?: () => void;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onEnded?: () => void;
+    onTimeUpdate?: (time: number) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Playback engine state
+ */
+interface PlaybackState {
     loading: boolean;
     error: string | null;
     recording: InternalRecording | null;
@@ -2353,7 +2941,7 @@ interface PlaybackState {
 /**
  * Playback controls
  */
-interface PlaybackControls$1 {
+interface PlaybackControls {
     setAudioElement: (element: HTMLAudioElement | null) => void;
     setVolume: (volume: number) => void;
     setMuted: (muted: boolean) => void;
@@ -2380,7 +2968,7 @@ interface PlaybackControls$1 {
 /**
  * Full playback engine result
  */
-type UsePlaybackEngineResult = PlaybackState & PlaybackControls$1;
+type UsePlaybackEngineResult = PlaybackState & PlaybackControls;
 /**
  * Player component props
  */
@@ -2521,93 +3109,53 @@ interface MCQResult {
     correctOptionIds?: string[];
 }
 
-/**
- * Active tool type - matches ToolType from @ct-courses/ui
- */
-type ActiveTool$1 = ToolType;
+type ActiveTool$2 = ToolType;
 /**
  * Props for the CoursePlayer component
  */
 interface CoursePlayerProps {
-    /** Pre-loaded recording data */
     recording?: CTRecording;
-    /** URL to a .ct file */
     recordingUrl?: string;
-    /** Recording ID to fetch from API */
     recordingId?: string;
-    /** Base API URL for fetching recordings */
     apiUrl?: string;
-    /** Authentication token */
     authToken?: string;
-    /** Go-Judge server URL */
     goJudgeUrl?: string;
-    /** Go-Judge API key */
     goJudgeApiKey?: string;
-    /** Theme setting */
     theme?: "light" | "dark" | "system";
-    /** Aspect ratio of the player */
     aspectRatio?: "16:9" | "4:3" | "auto";
-    /** Show playback controls toolbar */
     showToolbar?: boolean;
-    /** Show timeline below player */
     showTimeline?: boolean;
-    /** Show chapter markers */
     showChapters?: boolean;
-    /** Show tool sidebar */
     showToolSidebar?: boolean;
-    /** Auto-play when loaded */
     autoPlay?: boolean;
-    /** Default playback speed */
     defaultSpeed?: number;
-    /** Allow fullscreen mode */
     allowFullscreen?: boolean;
-    /** Default active tool */
-    defaultTool?: ActiveTool$1;
-    /** Called when player is ready */
+    defaultTool?: ActiveTool$2;
     onReady?: () => void;
-    /** Called when playback starts */
     onPlay?: () => void;
-    /** Called when playback pauses */
     onPause?: () => void;
-    /** Called on progress update */
     onProgress?: (time: number, duration: number) => void;
-    /** Called when playback completes */
     onComplete?: () => void;
-    /** Called on error */
     onError?: (error: Error) => void;
-    /** Called when entering interactive mode */
     onInteractionStart?: () => void;
-    /** Called when exiting interactive mode */
     onInteractionEnd?: (code: string) => void;
-    /** Called when tool changes */
     onToolChange?: (tool: string) => void;
-    /** Interaction points (MCQs) to display during playback */
     interactionPoints?: InteractionPoint[];
-    /** Pre-answered point IDs (skip these MCQs) */
     answeredPointIds?: Set<string>;
-    /** Called when a learner submits an MCQ answer. Host app validates server-side. */
     onSubmitAnswer?: (pointId: string, selectedOptionIds: string[]) => Promise<MCQResult>;
-    /** Info about the next lesson for auto-advance overlay */
     nextLesson?: {
         id: string;
         title: string;
     } | null;
-    /** Called when the player wants to navigate to the next lesson */
     onNavigateToLesson?: (lessonId: string) => void;
-    /** Called when the current lesson completes (before transition) */
     onLessonComplete?: () => void;
-    /** Lesson ID used to scope saved branches in localStorage */
     lessonId?: string;
-    /** Enable the branch save feature (default: true) */
     enableBranches?: boolean;
-    /** Called after a branch is saved */
     onBranchSave?: (branch: LearnerBranch) => void;
-    /** Called when a learner restores a saved branch */
     onBranchRestore?: (branch: LearnerBranch) => void;
-    /** Called after a branch is deleted */
     onBranchDelete?: (branchId: string) => void;
-    /** Maximum branches per lesson (default: 50) */
     maxBranches?: number;
+    sqlJsWasmUrl?: string;
 }
 /**
  * Imperative handle for CoursePlayer
@@ -2622,81 +3170,58 @@ interface CoursePlayerRef {
     getState(): PlaybackState$1;
     enterInteractiveMode(): void;
     exitInteractiveMode(): void;
-    setActiveTool(tool: ActiveTool$1): void;
+    setActiveTool(tool: ActiveTool$2): void;
 }
-/**
- * CoursePlayer component
- */
 declare const CoursePlayer: React__default.ForwardRefExoticComponent<CoursePlayerProps & React__default.RefAttributes<CoursePlayerRef>>;
 
-type ActiveTool = ToolType;
+type ActiveTool$1 = ToolType;
 /**
  * Props for StreamingCoursePlayer
  */
 interface StreamingCoursePlayerProps {
     /** URL to the streaming manifest.json */
     manifestUrl: string;
-    /** Theme setting */
     theme?: "light" | "dark" | "system";
-    /** Aspect ratio of the player */
     aspectRatio?: "16:9" | "4:3" | "auto";
-    /** Show playback controls toolbar */
     showToolbar?: boolean;
-    /** Show tool sidebar */
     showToolSidebar?: boolean;
-    /** Auto-play when loaded */
     autoPlay?: boolean;
-    /** Default playback speed */
     defaultSpeed?: number;
-    /** Allow fullscreen mode */
     allowFullscreen?: boolean;
-    /** Default active tool */
-    defaultTool?: ActiveTool;
-    /** Maximum chunks to cache */
+    defaultTool?: ActiveTool$1;
     maxCacheSize?: number;
-    /** Additional CSS class */
+    showWebcam?: boolean;
     className?: string;
-    /** Called when player is ready */
     onReady?: () => void;
-    /** Called when playback starts */
     onPlay?: () => void;
-    /** Called when playback pauses */
     onPause?: () => void;
-    /** Called on progress update */
     onProgress?: (time: number, duration: number) => void;
-    /** Called when playback completes */
     onComplete?: () => void;
-    /** Called on error */
     onError?: (error: Error) => void;
-    /** Called when buffering state changes */
     onBuffering?: (isBuffering: boolean) => void;
-    /** Called when tool changes */
     onToolChange?: (tool: string) => void;
-    /** Go-Judge server URL */
     goJudgeUrl?: string;
-    /** Go-Judge API key */
     goJudgeApiKey?: string;
-    /** Show chapter markers */
     showChapters?: boolean;
-    /** Called when entering interactive mode */
+    showTimeline?: boolean;
     onInteractionStart?: () => void;
-    /** Called when exiting interactive mode */
     onInteractionEnd?: (code: string) => void;
-    /** Interaction points (MCQs) to display during playback */
     interactionPoints?: InteractionPoint[];
-    /** Pre-answered point IDs (skip these MCQs) */
     answeredPointIds?: Set<string>;
-    /** Called when a learner submits an MCQ answer. Host app validates server-side. */
     onSubmitAnswer?: (pointId: string, selectedOptionIds: string[]) => Promise<MCQResult>;
-    /** Info about the next lesson for auto-advance overlay */
     nextLesson?: {
         id: string;
         title: string;
     } | null;
-    /** Called when the player wants to navigate to the next lesson */
     onNavigateToLesson?: (lessonId: string) => void;
-    /** Called when the current lesson completes (before transition) */
     onLessonComplete?: () => void;
+    lessonId?: string;
+    enableBranches?: boolean;
+    onBranchSave?: (branch: LearnerBranch) => void;
+    onBranchRestore?: (branch: LearnerBranch) => void;
+    onBranchDelete?: (branchId: string) => void;
+    maxBranches?: number;
+    sqlJsWasmUrl?: string;
 }
 /**
  * Imperative handle for StreamingCoursePlayer
@@ -2711,398 +3236,72 @@ interface StreamingCoursePlayerRef {
     getState(): PlaybackState$1;
     enterInteractiveMode(): void;
     exitInteractiveMode(): void;
-    setActiveTool(tool: ActiveTool): void;
+    setActiveTool(tool: ActiveTool$1): void;
     getManifest(): StreamingManifest | null;
     getBufferHealth(): RemoteBufferHealth;
 }
 declare const StreamingCoursePlayer: React__default.ForwardRefExoticComponent<StreamingCoursePlayerProps & React__default.RefAttributes<StreamingCoursePlayerRef>>;
 
-/**
- * usePlayback Hook
- *
- * Core playback engine hook using @ct-courses/core StateEngine.
- * Supports audio synchronization as master clock (no video/webcam).
- *
- * CRITICAL SYNC ARCHITECTURE:
- * - AUDIO is the MASTER CLOCK when media exists
- * - Events are applied based on audio.currentTime
- * - Without media, use requestAnimationFrame timing
- */
-
-/**
- * Playback state returned by the hook
- */
-interface PlaybackHookState {
-    /** Current playback state */
-    state: PlaybackState$1;
-    /** Current time in milliseconds */
-    currentTime: number;
-    /** Total duration in milliseconds */
-    duration: number;
-    /** Whether currently playing */
-    isPlaying: boolean;
-    /** Current playback speed */
-    speed: number;
-    /** Whether recording is loaded */
-    isLoaded: boolean;
-    /** Volume level (0-1) */
-    volume: number;
-    /** Whether audio is muted */
-    muted: boolean;
-    /** Whether user is interacting (paused with edits) */
-    isInteracting: boolean;
-}
-/**
- * Playback controls
- */
-interface PlaybackControls {
-    play(): void;
-    pause(): void;
-    seek(timeMs: number): void;
-    setSpeed(speed: number): void;
-    setVolume(volume: number): void;
-    setMuted(muted: boolean): void;
-    setAudioElement(audio: HTMLAudioElement | null): void;
-    setVideoElement(video: HTMLVideoElement | null): void;
-    enterInteractiveMode(): void;
-    exitInteractiveMode(): void;
-    setInteractiveCode(code: string): void;
-    setInteractiveLanguage(language: string): void;
-    setInteractiveTerminalLines(lines: PlaybackState$1['terminalLines']): void;
-    addInteractiveTerminalLines(lines: PlaybackState$1['terminalLines']): void;
-    setInteractiveExcalidrawScene(scene: PlaybackState$1['excalidrawScene']): void;
-    setInteractiveDocumentPage(page: number): void;
-    setInteractiveDocumentZoom(zoom: number): void;
-    setInteractiveDocumentScroll(scroll: {
-        x: number;
-        y: number;
-    }): void;
-    /** Inject a full branch snapshot into the interactive state. Only works when isInteracting is true. */
-    injectInteractiveState(snapshot: BranchSnapshot): void;
-    /** Get the engine's (instructor's) state at a given time, without affecting playback position. */
-    getEngineStateAtTime(timeMs: number): PlaybackState$1 | null;
-}
-/**
- * Options for usePlayback hook
- */
-interface UsePlaybackOptions {
-    recording: CTRecording | null;
+interface SharedProps {
+    theme?: "light" | "dark" | "system";
+    aspectRatio?: "16:9" | "4:3" | "auto";
+    showToolbar?: boolean;
+    showTimeline?: boolean;
+    showChapters?: boolean;
+    showToolSidebar?: boolean;
+    className?: string;
     autoPlay?: boolean;
     defaultSpeed?: number;
-    defaultVolume?: number;
+    allowFullscreen?: boolean;
+    defaultTool?: ToolType;
+    onReady?: () => void;
     onPlay?: () => void;
     onPause?: () => void;
     onProgress?: (time: number, duration: number) => void;
     onComplete?: () => void;
     onError?: (error: Error) => void;
-}
-/**
- * Hook for managing playback of a CT recording
- * Supports audio synchronization as master clock
- */
-declare function usePlayback(options: UsePlaybackOptions): PlaybackHookState & {
-    controls: PlaybackControls;
-};
-
-/**
- * useStreamingPlayback Hook
- *
- * Streaming playback engine hook for large recordings.
- * Supports lazy chunk loading, adaptive buffering, and efficient seeking.
- *
- * @packageDocumentation
- */
-
-/**
- * Buffer health status
- */
-interface BufferHealth {
-    status: 'healthy' | 'buffering' | 'critical' | 'empty';
-    loadedChunks: number;
-    totalChunks: number;
-    currentChunk: number;
-    bufferedTimeMs: number;
-    percentLoaded: number;
-}
-/**
- * Streaming metrics for performance monitoring
- */
-interface StreamingMetrics {
-    avgChunkLoadTimeMs: number;
-    chunkCacheHitRate: number;
-    bufferUnderrunCount: number;
-    avgBufferHealthPercent: number;
-    avgSeekTimeMs: number;
-    seekCacheHitRate: number;
-    peakChunksCached: number;
-    totalBytesLoaded: number;
-}
-/**
- * Streaming playback state
- */
-interface StreamingPlaybackState {
-    state: PlaybackState$1;
-    currentTime: number;
-    duration: number;
-    isPlaying: boolean;
-    speed: number;
-    isLoaded: boolean;
-    isBuffering: boolean;
-    bufferHealth: BufferHealth;
-    isStreaming: boolean;
-    metrics: StreamingMetrics;
-}
-/**
- * Streaming playback controls
- */
-interface StreamingPlaybackControls {
-    play(): void;
-    pause(): void;
-    seek(timeMs: number): Promise<void>;
-    setSpeed(speed: number): void;
-    preloadRange(startMs: number, endMs: number): Promise<void>;
-}
-/**
- * Options for useStreamingPlayback hook
- */
-interface UseStreamingPlaybackOptions {
-    recording: CTRecording | null;
-    chunkIndex?: CTEventChunkIndex | null;
-    loadChunk?: (chunkNumber: number) => Promise<ChunkLoadResult>;
-    autoPlay?: boolean;
-    defaultSpeed?: number;
-    bufferAhead?: number;
-    bufferBehind?: number;
-    maxChunksInMemory?: number;
-    onPlay?: () => void;
-    onPause?: () => void;
-    onProgress?: (time: number, duration: number) => void;
-    onComplete?: () => void;
     onBuffering?: (isBuffering: boolean) => void;
-    onChunkLoad?: (chunkNumber: number) => void;
-    onError?: (error: Error) => void;
-}
-/**
- * Hook for streaming playback of large CT recordings
- */
-declare function useStreamingPlayback(options: UseStreamingPlaybackOptions): StreamingPlaybackState & {
-    controls: StreamingPlaybackControls;
-};
-
-/**
- * useRemoteStreamingPlayback Hook
- *
- * React hook for streaming playback from a remote CDN/R2 storage.
- * Handles HLS audio streaming and lazy-loading of event chunks.
- *
- * This is designed for the streaming service architecture where:
- * - Audio is served via HLS adaptive bitrate streaming
- * - Events are stored in gzip-compressed chunks on CDN
- * - The manifest provides URLs for all resources
- *
- * @packageDocumentation
- */
-
-/**
- * Hook for remote streaming playback from CDN
- */
-declare function useRemoteStreamingPlayback(options: UseRemoteStreamingPlaybackOptions): RemoteStreamingPlaybackState & {
-    controls: RemoteStreamingPlaybackControls;
-};
-
-/**
- * useInteractiveMode Hook
- *
- * Manages interactive mode where users can edit code while paused.
- */
-
-/**
- * Interactive mode state
- */
-interface InteractiveModeState {
-    /** Whether interactive mode is active */
-    isActive: boolean;
-    /** Modified code (user edits) */
-    modifiedCode: string;
-    /** Whether code has been modified from original */
-    hasChanges: boolean;
-}
-/**
- * Interactive mode controls
- */
-interface InteractiveModeControls {
-    /** Enter interactive mode */
-    enter(): void;
-    /** Exit interactive mode */
-    exit(): void;
-    /** Update the modified code */
-    updateCode(code: string): void;
-    /** Reset code to original */
-    resetCode(): void;
-    /** Run the modified code */
-    runCode(): Promise<string>;
-}
-/**
- * Options for useInteractiveMode hook
- */
-interface UseInteractiveModeOptions {
-    /** Current playback state */
-    playbackState: PlaybackState$1;
-    /** Callback when entering interactive mode */
-    onEnter?: () => void;
-    /** Callback when exiting interactive mode */
-    onExit?: (code: string, hasChanges: boolean) => void;
-    /** Code execution function */
-    executeCode?: (code: string, language: string) => Promise<string>;
-}
-/**
- * Hook for managing interactive mode
- */
-declare function useInteractiveMode(options: UseInteractiveModeOptions): InteractiveModeState & {
-    controls: InteractiveModeControls;
-};
-
-/**
- * useAudioSync Hook
- *
- * Synchronizes audio playback with event state.
- * Handles audio/event drift and maintains sync within tolerance.
- *
- * @packageDocumentation
- */
-/**
- * Audio sync state
- */
-interface AudioSyncState {
-    /** Current audio time in ms */
-    audioTime: number;
-    /** Current event time in ms */
-    eventTime: number;
-    /** Drift between audio and events (ms) */
-    drift: number;
-    /** Is sync healthy (within tolerance) */
-    isSynced: boolean;
-    /** Is audio loaded */
-    isAudioReady: boolean;
-}
-/**
- * Audio sync controls
- */
-interface AudioSyncControls {
-    /** Sync events to audio time */
-    syncToAudio(): void;
-    /** Sync audio to event time */
-    syncAudioTo(timeMs: number): void;
-    /** Force resync */
-    forceResync(): void;
-}
-/**
- * Options for useAudioSync hook
- */
-interface UseAudioSyncOptions {
-    /** Reference to audio element */
-    audioRef: React.RefObject<HTMLAudioElement>;
-    /** Current event time */
-    eventTime: number;
-    /** Is currently playing */
-    isPlaying: boolean;
-    /** Playback speed */
-    speed: number;
-    /** Maximum allowed drift in ms before resync (default: 500ms) */
-    driftTolerance?: number;
-    /** Callback when audio time updates */
-    onAudioTimeUpdate?: (timeMs: number) => void;
-    /** Callback when sync is lost */
-    onSyncLost?: (drift: number) => void;
-    /** Callback when sync is restored */
-    onSyncRestored?: () => void;
-}
-/**
- * Hook for synchronizing audio playback with event state
- */
-declare function useAudioSync(options: UseAudioSyncOptions): AudioSyncState & {
-    controls: AudioSyncControls;
-};
-/**
- * Hook for managing audio element lifecycle
- */
-declare function useAudioElement(src: string | null): {
-    audioRef: React__default.MutableRefObject<HTMLAudioElement | null>;
-    isLoaded: boolean;
-    error: Error | null;
-    duration: number;
-};
-
-/**
- * useVideoSync Hook
- *
- * Synchronizes video playback with event state.
- * Handles video/event drift and maintains sync within tolerance.
- *
- * @packageDocumentation
- */
-/**
- * Video sync state
- */
-interface VideoSyncState {
-    /** Current video time in ms */
-    videoTime: number;
-    /** Current event time in ms */
-    eventTime: number;
-    /** Drift between video and events (ms) */
-    drift: number;
-    /** Is sync healthy (within tolerance) */
-    isSynced: boolean;
-    /** Is video loaded */
-    isVideoReady: boolean;
-}
-/**
- * Video sync controls
- */
-interface VideoSyncControls {
-    /** Sync events to video time */
-    syncToVideo(): void;
-    /** Sync video to event time */
-    syncVideoTo(timeMs: number): void;
-    /** Force resync */
-    forceResync(): void;
+    onToolChange?: (tool: string) => void;
+    onInteractionStart?: () => void;
+    onInteractionEnd?: (code: string) => void;
+    goJudgeUrl?: string;
+    goJudgeApiKey?: string;
+    interactionPoints?: InteractionPoint[];
+    answeredPointIds?: Set<string>;
+    onSubmitAnswer?: (pointId: string, selectedOptionIds: string[]) => Promise<MCQResult>;
+    nextLesson?: {
+        id: string;
+        title: string;
+    } | null;
+    onNavigateToLesson?: (lessonId: string) => void;
+    onLessonComplete?: () => void;
+    lessonId?: string;
+    enableBranches?: boolean;
+    onBranchSave?: (branch: LearnerBranch) => void;
+    onBranchRestore?: (branch: LearnerBranch) => void;
+    onBranchDelete?: (branchId: string) => void;
+    maxBranches?: number;
+    sqlJsWasmUrl?: string;
 }
-/**
- * Options for useVideoSync hook
- */
-interface UseVideoSyncOptions {
-    /** Reference to video element */
-    videoRef: React.RefObject<HTMLVideoElement>;
-    /** Current event time */
-    eventTime: number;
-    /** Is currently playing */
-    isPlaying: boolean;
-    /** Playback speed */
-    speed: number;
-    /** Maximum allowed drift in ms before resync (default: 500ms) */
-    driftTolerance?: number;
-    /** Callback when video time updates */
-    onVideoTimeUpdate?: (timeMs: number) => void;
-    /** Callback when sync is lost */
-    onSyncLost?: (drift: number) => void;
-    /** Callback when sync is restored */
-    onSyncRestored?: () => void;
+interface CTPlayerProps extends SharedProps {
+    /**
+     * Content source URL.
+     * - Ending in `.json` or containing `/manifest` → HLS streaming mode
+     * - Ending in `.ct` or any other URL → local file mode
+     * - Omit if passing `recording` directly
+     */
+    src?: string;
+    /** Pre-loaded CTRecording object (skips fetch). */
+    recording?: CTRecording;
+    maxCacheSize?: number;
+    showWebcam?: boolean;
+    apiUrl?: string;
+    authToken?: string;
+    recordingId?: string;
 }
-/**
- * Hook for synchronizing video playback with event state
- */
-declare function useVideoSync(options: UseVideoSyncOptions): VideoSyncState & {
-    controls: VideoSyncControls;
-};
-/**
- * Hook for managing video element lifecycle
- */
-declare function useVideoElement(src: string | null): {
-    videoRef: React__default.MutableRefObject<HTMLVideoElement | null>;
-    isLoaded: boolean;
-    error: Error | null;
-    duration: number;
-};
+/** Union ref — exposes whichever component's ref is active. */
+type CTPlayerRef = CoursePlayerRef | StreamingCoursePlayerRef;
+declare const CTPlayer: React__default.ForwardRefExoticComponent<CTPlayerProps & React__default.RefAttributes<CTPlayerRef>>;
 
 /**
  * useInteractionPoints — monitors playback time and triggers MCQ pauses.
@@ -3398,11 +3597,15 @@ interface PlayerControlsProps {
     onBranchPanelToggle?: () => void;
     /** Whether the learner is in interactive/editing mode */
     isInteractive?: boolean;
+    /** Whether webcam overlay is visible */
+    webcamVisible?: boolean;
+    /** Toggle webcam visibility */
+    onWebcamToggle?: () => void;
     showMarkers?: boolean;
     compact?: boolean;
     containerRef?: React__default__default.RefObject<HTMLElement>;
 }
-declare function PlayerControls({ isPlaying, currentTime, duration, volume, muted, playbackSpeed, markers, isFullscreen, videoQualityLevels, videoQualityLevel, onVideoQualityChange, onPlayPause, onSeek, onSeekStart, onSeekEnd, onSkip, onRestart, onVolumeChange, onMuteToggle, onSpeedChange, onFullscreenToggle, onEditorInteraction, interactionPoints, branches, onBranchClick, branchCount, isBranchPanelOpen, onBranchPanelToggle, isInteractive, showMarkers, compact, }: PlayerControlsProps): react_jsx_runtime.JSX.Element;
+declare function PlayerControls({ isPlaying, currentTime, duration, volume, muted, playbackSpeed, markers, isFullscreen, videoQualityLevels, videoQualityLevel, onVideoQualityChange, onPlayPause, onSeek, onSeekStart, onSeekEnd, onSkip, onRestart, onVolumeChange, onMuteToggle, onSpeedChange, onFullscreenToggle, onEditorInteraction, interactionPoints, branches, onBranchClick, branchCount, isBranchPanelOpen, onBranchPanelToggle, isInteractive, webcamVisible, onWebcamToggle, showMarkers, compact, }: PlayerControlsProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Timeline Component
@@ -3681,9 +3884,6 @@ interface CustomSize {
 }
 interface WebcamOverlayProps {
     src: string | null;
-    currentTime: number;
-    isPlaying: boolean;
-    playbackRate?: number;
     position?: OverlayPosition;
     customPosition?: CustomPosition;
     size?: OverlaySize;
@@ -3698,9 +3898,6 @@ interface WebcamOverlayProps {
     onSizeChange?: (size: CustomSize) => void;
     onVisibilityToggle?: () => void;
     onVideoRef?: (video: HTMLVideoElement | null) => void;
-    muted?: boolean;
-    volume?: number;
-    syncTolerance?: number;
     /** Whether webcam is in maximized (full overlay) mode - from playback events */
     maximized?: boolean;
     /** Callback when user clicks minimize button */
@@ -3708,6 +3905,6 @@ interface WebcamOverlayProps {
     /** Callback when user clicks maximize button */
     onMaximize?: () => void;
 }
-declare function WebcamOverlay({ src, currentTime: _currentTime, isPlaying: _isPlaying, playbackRate: _playbackRate, position, customPosition, size, customSize, visible, draggable, resizable: _resizable, showControls: _showControls, borderRadius, opacity, onPositionChange, onSizeChange: _onSizeChange, onVisibilityToggle: _onVisibilityToggle, onVideoRef, muted: _muted, volume: _volume, syncTolerance: _syncTolerance, maximized, onMinimize, onMaximize, }: WebcamOverlayProps): JSX.Element | null;
+declare function WebcamOverlay({ src, position, customPosition, size, customSize, visible, draggable, resizable: _resizable, showControls: _showControls, borderRadius, opacity, onPositionChange, onSizeChange: _onSizeChange, onVisibilityToggle: _onVisibilityToggle, onVideoRef, maximized, onMinimize, onMaximize, }: WebcamOverlayProps): JSX.Element;
 
-export { AudioOverlay, type AudioOverlayProps, type AudioQuality, type AudioSyncControls, type AudioSyncState, type BackendAdapter, BranchPanel, type BranchPanelProps, BranchSavedToast, type BranchSavedToastProps, type BranchSnapshot, BranchTransition, type BranchTransitionProps, type BufferHealth, type CTEvent, type CTManifest, type CTMarker, type CTReadOptions, type CTRecording, CoursePlayer, type CoursePlayerProps, type CoursePlayerRef, type CursorPosition, type CustomPosition$1 as CustomPosition, DocumentPanel, type DocumentPanelProps, FileExplorer, type FileExplorerProps, type FileSystemSnapshot, type HLSPlayerInstance, HLS_EVENTS, IDEPanel, type IDEPanelProps, type InteractionPoint, type InternalEvent, type InternalRecording, type LearnerBranch, MCQOverlay, type MCQOverlayProps, type MCQResult, type MCQSubmission, type OverlayPosition$1 as OverlayPosition, type PanelMode, type PlaybackControls$1 as PlaybackControls, type PlaybackEngineConfig, type PlaybackHookState, type PlaybackState, PlayerControls, type PlayerControlsProps$1 as PlayerControlsProps, type PlayerProps, type PlayerRef, type RecordingMarker, type RemoteBufferHealth, type RemoteStreamingMetrics, type RemoteStreamingPlaybackControls, type RemoteStreamingPlaybackState, SaveBranchButton, type SaveBranchButtonProps, type SpeedSelectorProps, type StreamingAudioConfig, type StreamingConfig, StreamingCoursePlayer, type StreamingCoursePlayerProps, type StreamingCoursePlayerRef, type StreamingEventsConfig, type StreamingManifest, type StreamingMetrics, type StreamingPlaybackControls, type StreamingPlaybackState, type StreamingRecordingInfo, Terminal, type TerminalLineData, type TerminalProps, Timeline, type TimelineProps$1 as TimelineProps, ToolSidebar, type ToolSidebarProps, type ToolType, UnsavedBranchPrompt, type UnsavedBranchPromptProps, type UseAudioSyncOptions, type UseBranchesOptions, type UseBranchesResult, type UseBranchingOptions, type UseBranchingResult, type UseInteractionPointsOptions, type UseInteractionPointsResult, type UsePlaybackEngineResult, type UsePlaybackOptions, type UseRemoteStreamingPlaybackOptions, type UseVideoSyncOptions, type ValidationResult$1 as ValidationResult, type VideoSyncControls, type VideoSyncState, type VolumeControlProps, WebcamOverlay, type WebcamOverlayProps, WhiteboardPanel, type WhiteboardPanelProps, type WriteCTOptions, canPlayHls, createEmptyRecording, createHlsPlayer, deleteBranch as deleteBranchFromStorage, destroyHlsPlayer, formatBranchTime, hasNativeHlsSupport, isHlsSupported, loadBranches, readCTFile, readCTManifest, saveBranch as saveBranchToStorage, updateBranchLabel, useAudioElement, useAudioSync, useBranches, useBranching, useInteractionPoints, useInteractiveMode, usePlayback, usePlayback as usePlaybackEngine, useRemoteStreamingPlayback, useStreamingPlayback, useVideoElement, useVideoSync, validateCTFile, writeCTFile };
+export { AudioOverlay, type AudioOverlayProps, type AudioQuality, type BackendAdapter, BranchPanel, type BranchPanelProps, BranchSavedToast, type BranchSavedToastProps, type BranchSnapshot, BranchTransition, type BranchTransitionProps, type CTEvent, type CTManifest, type CTMarker, CTPlayer, type CTPlayerProps, type CTPlayerRef, type CTReadOptions, type CTRecording, CoursePlayer, type CoursePlayerProps, type CoursePlayerRef, type CursorPosition, type CustomPosition$1 as CustomPosition, DocumentPanel, type DocumentPanelProps, FileExplorer, type FileExplorerProps, type FileSystemSnapshot, type HLSPlayerInstance, HLS_EVENTS, HlsStreamingAdapter, IDEPanel, type IDEPanelProps, type InteractionPoint, type InternalEvent, type InternalRecording, type LearnerBranch, LocalFileAdapter, MCQOverlay, type MCQOverlayProps, type MCQResult, type MCQSubmission, MasterClock, type MediaSourceAdapter, type OverlayPosition$1 as OverlayPosition, type PanelMode, type PlaybackControls, type PlaybackEngineConfig, type PlaybackState, PlaybackStateMachine, type PlayerAction, PlayerControls, type PlayerControlsProps$1 as PlayerControlsProps, PlayerEngine, type PlayerEngineConfig, PlayerErrorBoundary, type PlayerProps, type PlayerRef, type PlayerSnapshot, type PlayerState, type RecordingMarker, type RemoteBufferHealth, SaveBranchButton, type SaveBranchButtonProps, type SpeedSelectorProps, type StreamingAudioConfig, type StreamingConfig, StreamingCoursePlayer, type StreamingCoursePlayerProps, type StreamingCoursePlayerRef, type StreamingEventsConfig, type StreamingManifest, type StreamingRecordingInfo, Terminal, type TerminalLineData, type TerminalProps, Timeline, type TimelineProps$1 as TimelineProps, ToolSidebar, type ToolSidebarProps, type ToolType, UnsavedBranchPrompt, type UnsavedBranchPromptProps, type UseBranchesOptions, type UseBranchesResult, type UseBranchingOptions, type UseBranchingResult, type UseInteractionPointsOptions, type UseInteractionPointsResult, type UsePlaybackEngineResult, type UsePlayerEngineResult, type ValidationResult$1 as ValidationResult, type VolumeControlProps, WebcamOverlay, type WebcamOverlayProps, WhiteboardPanel, type WhiteboardPanelProps, type WriteCTOptions, canPlayHls, createEmptyRecording, createHlsPlayer, deleteBranch as deleteBranchFromStorage, destroyHlsPlayer, formatBranchTime, hasNativeHlsSupport, isHlsSupported, loadBranches, readCTFile, readCTManifest, saveBranch as saveBranchToStorage, updateBranchLabel, useBranches, useBranching, useInteractionPoints, usePlayerEngine, validateCTFile, writeCTFile };