@ct-player/embed 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,2716 @@
+import * as react from 'react';
+import react__default from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import Hls from 'hls.js';
+
+/**
+ * CT Format Event Types
+ *
+ * Defines all event types and their data structures for the .ct format.
+ */
+/**
+ * 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' | 'document_load' | 'document_page' | 'document_zoom' | 'document_scroll' | 'document_clear' | 'file_create' | 'file_update' | 'file_delete' | 'file_rename' | 'file_switch' | 'file_select' | 'file_change' | 'file_creation_start' | 'file_creation_input' | 'file_creation_cancel' | 'cursor_move' | 'cursor_click' | 'cursor_enter' | 'cursor_leave' | 'tool_switch' | 'tool' | 'marker';
+/**
+ * Base event structure with generic type parameter
+ */
+interface CTEventBase<T extends CTEventType = CTEventType> {
+    /** Event type identifier */
+    type: T;
+    /** Time in milliseconds from recording start */
+    time: number;
+    /** Event-specific data payload */
+    data: CTEventDataMap[T];
+}
+/**
+ * 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<'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<'file_select'> | CTEventBase<'file_change'> | CTEventBase<'file_creation_start'> | CTEventBase<'file_creation_input'> | CTEventBase<'file_creation_cancel'> | CTEventBase<'cursor_move'> | CTEventBase<'cursor_click'> | CTEventBase<'cursor_enter'> | CTEventBase<'cursor_leave'> | CTEventBase<'tool_switch'> | CTEventBase<'tool'> | CTEventBase<'marker'>;
+/**
+ * Mapping of event types to their data structures
+ */
+interface CTEventDataMap {
+    init: InitEventData;
+    code: CodeEventData;
+    code_edit: CodeEditEventData;
+    language: LanguageEventData;
+    terminal: TerminalEventData;
+    terminal_input: TerminalInputEventData;
+    stroke_start: StrokeStartEventData;
+    whiteboard_points: WhiteboardPointsEventData;
+    stroke_end: StrokeEndEventData;
+    whiteboard_stroke: WhiteboardStrokeEventData;
+    whiteboard_clear: WhiteboardClearEventData;
+    whiteboard_undo: WhiteboardUndoEventData;
+    excalidraw_scene: ExcalidrawSceneEventData;
+    excalidraw_clear: ExcalidrawClearEventData;
+    document_load: DocumentLoadEventData;
+    document_page: DocumentPageEventData;
+    document_zoom: DocumentZoomEventData;
+    document_scroll: DocumentScrollEventData;
+    document_clear: DocumentClearEventData;
+    file_create: FileCreateEventData;
+    file_update: FileUpdateEventData;
+    file_delete: FileDeleteEventData;
+    file_rename: FileRenameEventData;
+    file_switch: FileSwitchEventData;
+    file_creation_start: FileCreationStartEventData;
+    file_creation_input: FileCreationInputEventData;
+    file_creation_cancel: FileCreationCancelEventData;
+    cursor_move: CursorMoveEventData;
+    cursor_click: CursorClickEventData;
+    cursor_enter: CursorEnterEventData;
+    cursor_leave: CursorLeaveEventData;
+    tool_switch: ToolSwitchEventData;
+    marker: MarkerEventData;
+    tool: ToolEventData;
+    whiteboard: WhiteboardEventData;
+    whiteboard_point: WhiteboardPointEventData;
+    file_select: FileSelectEventData;
+    file_change: FileChangeEventData;
+}
+/**
+ * Tool types for tool switching
+ */
+type Tool = 'code' | 'terminal' | 'whiteboard' | 'document';
+/**
+ * Terminal line entry
+ */
+interface TerminalLine$1 {
+    type: 'input' | 'output' | 'error' | 'system';
+    text: string;
+}
+/**
+ * 2D point with optional pressure
+ */
+interface Point {
+    x: number;
+    y: number;
+    pressure?: number;
+}
+/**
+ * Drawing stroke
+ */
+interface Stroke {
+    id: string;
+    color: string;
+    width: number;
+    opacity: number;
+    tool: StrokeTool;
+    points: Point[];
+}
+/**
+ * Stroke tool types
+ */
+type StrokeTool = 'pen' | 'eraser' | 'highlighter';
+/**
+ * Document reference data
+ */
+interface DocumentData {
+    id: string;
+    name: string;
+    type: string;
+    data?: string;
+    assetRef?: string;
+    numPages: number;
+}
+/**
+ * Excalidraw element types we support
+ */
+type ExcalidrawElementType = 'rectangle' | 'ellipse' | 'diamond' | 'line' | 'arrow' | 'freedraw' | 'text' | 'image' | 'frame' | 'group';
+/**
+ * Excalidraw fill style
+ */
+type ExcalidrawFillStyle = 'solid' | 'hachure' | 'cross-hatch' | 'none';
+/**
+ * Excalidraw stroke style
+ */
+type ExcalidrawStrokeStyle = 'solid' | 'dashed' | 'dotted';
+/**
+ * Strongly typed Excalidraw element (v1.1.0+)
+ * This replaces the previous `unknown[]` for type safety
+ */
+interface CTExcalidrawElement {
+    id: string;
+    type: ExcalidrawElementType | string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    angle: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: ExcalidrawFillStyle;
+    strokeWidth: number;
+    strokeStyle: ExcalidrawStrokeStyle;
+    roughness: number;
+    opacity: number;
+    points?: number[][];
+    text?: string;
+    fontSize?: number;
+    fontFamily?: number;
+    textAlign?: 'left' | 'center' | 'right';
+    groupIds?: string[];
+    frameId?: string | null;
+    isDeleted: boolean;
+    locked: boolean;
+    fileId?: string;
+    [key: string]: unknown;
+}
+/**
+ * Excalidraw app state we care about
+ */
+interface CTExcalidrawAppState {
+    viewBackgroundColor: string;
+    zoom: {
+        value: number;
+    };
+    scrollX: number;
+    scrollY: number;
+    selectedElementIds?: Record<string, boolean>;
+}
+/**
+ * Excalidraw file (for images, etc.)
+ */
+interface CTExcalidrawFile {
+    mimeType: string;
+    id: string;
+    dataURL?: string;
+    assetRef?: string;
+}
+/**
+ * Excalidraw scene structure (v1.1.0 with strong typing)
+ */
+interface ExcalidrawScene {
+    elements: CTExcalidrawElement[];
+    appState?: CTExcalidrawAppState;
+    files?: Record<string, CTExcalidrawFile>;
+    /** Excalidraw library version for migrations (v1.1.0+) */
+    excalidrawVersion?: string;
+    /** Our schema version (v1.1.0+) */
+    ctSchemaVersion?: number;
+}
+/**
+ * Full state snapshot (used at recording start or after edits)
+ */
+interface InitEventData {
+    code: string;
+    language: string;
+    terminal: TerminalLine$1[];
+    terminalInput: string;
+    strokes: Stroke[];
+    excalidrawScene?: ExcalidrawScene;
+    tool: Tool;
+    currentFile?: string;
+    fileSystem: Record<string, string>;
+    document?: DocumentData;
+    documentPage: number;
+    documentZoom: number;
+    documentScroll: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Code content change
+ */
+interface CodeEventData {
+    content: string;
+    language?: string;
+    cursorPosition?: {
+        line: number;
+        column: number;
+    };
+}
+/**
+ * Granular code edit event - for smooth typing playback
+ * Records individual text operations (insert/delete) at specific positions.
+ */
+interface CodeEditEventData {
+    /** Type of edit operation */
+    operation: 'insert' | 'delete';
+    /** Start position of the edit */
+    position: {
+        line: number;
+        column: number;
+        /** Absolute character offset from start of file */
+        offset: number;
+    };
+    /** Text being inserted (for 'insert' operations) */
+    text?: string;
+    /** Number of characters deleted (for 'delete' operations) */
+    deleteCount?: number;
+    /** Direction of deletion: 'forward' (Delete key) or 'backward' (Backspace) */
+    deleteDirection?: 'forward' | 'backward';
+    /** Current cursor position after the edit */
+    cursorPosition?: {
+        line: number;
+        column: number;
+    };
+}
+/**
+ * Language change
+ */
+interface LanguageEventData {
+    language: string;
+}
+/**
+ * Terminal output (batched) - v1.1.0 optimized format
+ */
+interface TerminalBatchedOutput {
+    /** Full output text (may be multi-line) */
+    text: string;
+    /** Output stream */
+    stream: 'stdout' | 'stderr';
+}
+/**
+ * Terminal cursor position
+ */
+interface TerminalCursorPosition {
+    row: number;
+    col: number;
+}
+/**
+ * Terminal output event
+ *
+ * v1.1.0 adds batched output support for efficiency.
+ * The `output` field is preferred over `lines` for new recordings.
+ */
+interface TerminalEventData {
+    /** Legacy line-by-line format (v1.0.0) */
+    lines?: TerminalLine$1[];
+    /** Batched output format (v1.1.0+) - preferred */
+    output?: TerminalBatchedOutput | string;
+    /** Whether terminal was cleared */
+    cleared?: boolean;
+    /** Cursor position change (v1.1.0+) */
+    cursorPosition?: TerminalCursorPosition;
+    /** Legacy: append lines to existing (v1.0.0) */
+    addedLines?: boolean;
+    /** Legacy: command that was executed (v1.0.0) */
+    command?: string;
+    /** Legacy: whether terminal input was cleared (v1.0.0) */
+    inputCleared?: boolean;
+}
+/**
+ * Keystroke timing for realistic playback animation
+ */
+interface TerminalKeystroke {
+    /** Character typed */
+    char: string;
+    /** Delay in ms since previous keystroke */
+    delay: number;
+}
+/**
+ * Terminal input event (user typing)
+ *
+ * v1.1.0 adds keystroke timing for realistic playback.
+ */
+interface TerminalInputEventData {
+    /** Final input string (what was typed) */
+    input?: string;
+    /** Legacy: input value (v1.0.0) */
+    value?: string;
+    /** Keystroke timing for animation (v1.1.0+) */
+    keystrokes?: TerminalKeystroke[];
+    /** Whether Enter was pressed (command submitted) (v1.1.0+) */
+    submitted?: boolean;
+}
+/**
+ * Begin drawing stroke
+ */
+interface StrokeStartEventData {
+    id: string;
+    color: string;
+    width: number;
+    opacity?: number;
+    tool: StrokeTool;
+}
+/**
+ * Batch of points in current stroke
+ */
+interface WhiteboardPointsEventData {
+    strokeId: string;
+    points: Point[];
+}
+/**
+ * Finish stroke
+ */
+interface StrokeEndEventData {
+    strokeId: string;
+}
+/**
+ * Complete stroke at once
+ */
+interface WhiteboardStrokeEventData {
+    stroke: Stroke;
+}
+/**
+ * Clear entire whiteboard
+ */
+interface WhiteboardClearEventData {
+}
+/**
+ * Undo last stroke
+ */
+interface WhiteboardUndoEventData {
+    strokeId?: string;
+}
+/**
+ * Excalidraw full scene update
+ */
+interface ExcalidrawSceneEventData {
+    elements: unknown[];
+    appState?: unknown;
+    files?: Record<string, unknown>;
+}
+/**
+ * Clear Excalidraw scene
+ */
+interface ExcalidrawClearEventData {
+}
+/**
+ * Load document
+ */
+interface DocumentLoadEventData {
+    id: string;
+    name: string;
+    type: string;
+    data?: string;
+    assetRef?: string;
+    numPages: number;
+}
+/**
+ * Document page change
+ */
+interface DocumentPageEventData {
+    page: number;
+}
+/**
+ * Document zoom change
+ */
+interface DocumentZoomEventData {
+    zoom: number;
+}
+/**
+ * Document scroll position
+ */
+interface DocumentScrollEventData {
+    x: number;
+    y: number;
+}
+/**
+ * Remove document
+ */
+interface DocumentClearEventData {
+}
+/**
+ * Create new file
+ */
+interface FileCreateEventData {
+    path: string;
+    content: string;
+    language?: string;
+}
+/**
+ * Update file content
+ */
+interface FileUpdateEventData {
+    path: string;
+    content: string;
+}
+/**
+ * Delete file
+ */
+interface FileDeleteEventData {
+    path: string;
+}
+/**
+ * Rename file
+ */
+interface FileRenameEventData {
+    oldPath: string;
+    newPath: string;
+}
+/**
+ * Switch active file
+ */
+interface FileSwitchEventData {
+    path: string;
+}
+/**
+ * File/folder creation UI started - shows the inline input
+ */
+interface FileCreationStartEventData {
+    /** Type of item being created */
+    type: 'file' | 'folder';
+    /** Parent folder path where the item is being created */
+    parentPath: string;
+}
+/**
+ * File/folder creation input changed - for typing animation
+ */
+interface FileCreationInputEventData {
+    /** Current value of the input field */
+    value: string;
+}
+/**
+ * File/folder creation cancelled - hides the inline input
+ */
+interface FileCreationCancelEventData {
+    /** Reason for cancellation (optional) */
+    reason?: 'escape' | 'blur' | 'other';
+}
+/**
+ * Cursor position update
+ */
+interface CursorMoveEventData {
+    x: number;
+    y: number;
+    visible: boolean;
+}
+/**
+ * Click event
+ */
+interface CursorClickEventData {
+    x: number;
+    y: number;
+    button: 'left' | 'right' | 'middle';
+}
+/**
+ * Cursor entered content area
+ */
+interface CursorEnterEventData {
+    area: string;
+}
+/**
+ * Cursor left content area
+ */
+interface CursorLeaveEventData {
+    area: string;
+}
+/**
+ * Switch active tool
+ */
+interface ToolSwitchEventData {
+    tool: Tool;
+}
+/**
+ * Marker event (metadata only)
+ */
+interface MarkerEventData {
+    id: string;
+    label: string;
+    type: 'chapter' | 'highlight' | 'quiz' | 'note';
+}
+/**
+ * Legacy tool event (same as tool_switch)
+ */
+interface ToolEventData {
+    tool: Tool;
+}
+/**
+ * Legacy whiteboard full strokes replacement
+ */
+interface WhiteboardEventData {
+    strokes: Stroke[];
+}
+/**
+ * Legacy single point add to current stroke
+ */
+interface WhiteboardPointEventData {
+    point: Point;
+}
+/**
+ * Legacy file select event
+ */
+interface FileSelectEventData {
+    path: string;
+    content?: string;
+    language?: string;
+}
+/**
+ * Legacy file change event
+ */
+interface FileChangeEventData {
+    path: string;
+    content: string;
+}
+
+/**
+ * CT Format State Types
+ *
+ * Defines the playback state structure used by the state engine.
+ */
+
+/**
+ * Complete playback state at any point in time
+ */
+interface PlaybackState$1 {
+    /** Current code content */
+    code: string;
+    /** Current programming language */
+    language: string;
+    /** Terminal output history */
+    terminalLines: TerminalLine$1[];
+    /** Current terminal input buffer */
+    terminalInput: string;
+    /** Completed strokes on whiteboard (legacy) */
+    strokes: Stroke[];
+    /** Current Excalidraw scene (modern whiteboard) */
+    excalidrawScene: ExcalidrawScene | null;
+    /** Currently active tool */
+    activeTool: Tool;
+    /** Currently active file path */
+    currentFile: string | null;
+    /** Virtual file system (path → content) */
+    fileSystem: Record<string, string>;
+    /** Currently loaded document */
+    documentData: DocumentData | null;
+    /** Current document page number */
+    documentPage: number;
+    /** Current document zoom level */
+    documentZoom: number;
+    /** Current document scroll position */
+    documentScroll: {
+        x: number;
+        y: number;
+    };
+    /** Cursor position and visibility */
+    cursorPosition: {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    /** File creation UI state - for showing inline input during playback */
+    fileCreation: FileCreationState | null;
+}
+/**
+ * State for file/folder creation UI display during playback
+ */
+interface FileCreationState {
+    /** Type of item being created */
+    type: 'file' | 'folder';
+    /** Parent folder path */
+    parentPath: string;
+    /** Current input value (filename being typed) */
+    inputValue: string;
+}
+
+/**
+ * CT Format Chunked Events Types
+ *
+ * Defines types for the chunked events architecture in v1.1.0.
+ * Events are split into time-indexed chunks for:
+ * - Fast seeking (load only needed chunks)
+ * - Memory efficiency (unload distant chunks)
+ * - Progressive loading (start playback before full load)
+ */
+
+/**
+ * A single chunk of events covering a time range
+ */
+interface CTEventChunk {
+    /** Chunk identifier (0, 1, 2, ...) */
+    id: number;
+    /** First event time in this chunk (milliseconds) */
+    startTimeMs: number;
+    /** Last event time in this chunk (milliseconds) */
+    endTimeMs: number;
+    /** Events in this chunk */
+    events: CTEvent[];
+    /** Optional state snapshot at the start of this chunk for fast seeking */
+    snapshotAtStart?: PlaybackState$1;
+}
+/**
+ * Individual chunk metadata in the index
+ */
+interface CTChunkInfo {
+    /** Chunk index (0, 1, 2, ...) */
+    id: number;
+    /** Filename (e.g., "chunk-000.json" or "chunk-000.json.gz") */
+    file: string;
+    /** First event time in this chunk (milliseconds) */
+    startTimeMs: number;
+    /** Last event time in this chunk (milliseconds) */
+    endTimeMs: number;
+    /** Number of events in this chunk */
+    eventCount: number;
+    /** SHA-256 checksum for integrity verification */
+    checksum: string;
+    /** File size in bytes (for progress reporting) */
+    sizeBytes: number;
+    /** Whether this chunk has a state snapshot at its start */
+    hasSnapshot: boolean;
+}
+/**
+ * State snapshot reference
+ */
+interface CTStateSnapshotRef {
+    /** Chunk ID where snapshot is stored */
+    chunkId: number;
+    /** Snapshot timestamp (milliseconds) */
+    timeMs: number;
+    /** Snapshot file path (e.g., "snapshots/snap-003.json") */
+    file: string;
+}
+/**
+ * Event Chunk Index (events/index.json)
+ *
+ * This is the first file loaded when opening a .ct file.
+ * It tells the player which chunks exist and their time ranges.
+ */
+interface CTEventChunkIndex {
+    /** Format version for the index itself */
+    formatVersion: string;
+    /** All chunks in this recording */
+    chunks: CTChunkInfo[];
+    /** State snapshots for fast seeking (every N chunks) */
+    snapshots?: CTStateSnapshotRef[];
+    /** Total event count across all chunks */
+    totalEventCount: number;
+    /** Total number of chunks */
+    totalChunks: number;
+    /** Total duration in milliseconds */
+    totalDuration: number;
+    /** Default chunk duration in milliseconds */
+    chunkDurationMs: number;
+}
+/**
+ * Chunk load result
+ */
+interface ChunkLoadResult {
+    /** The loaded chunk (undefined if failed) */
+    chunk?: CTEventChunk;
+    /** Load time in milliseconds */
+    loadTimeMs: number;
+    /** Whether this was a cache hit */
+    fromCache: boolean;
+    /** Error message if load failed */
+    error?: string;
+}
+/** State snapshot stored at chunk boundary for fast seeking */
+interface StateSnapshot {
+    /** Chunk ID where this snapshot applies */
+    chunkId: number;
+    /** Timestamp in milliseconds */
+    timeMs: number;
+    /** Complete playback state at this point */
+    state: PlaybackState$1;
+}
+
+/**
+ * CT Format Access Control Types
+ *
+ * Defines types for content protection, licensing, and DRM in v1.1.0.
+ * Supports multiple licensing models from free to enterprise.
+ */
+/**
+ * License type for content access
+ */
+type CTLicenseType = 'public' | 'unlisted' | 'private' | 'paid';
+/**
+ * DRM provider options
+ */
+type CTDRMProvider = 'widevine' | 'fairplay' | 'playready' | 'custom';
+/**
+ * Watermark type
+ */
+type CTWatermarkType = 'visible' | 'invisible' | 'both';
+/**
+ * Encryption configuration for protected content
+ */
+interface CTEncryptionConfig {
+    /** Encryption algorithm (only AES-256-GCM supported) */
+    algorithm: 'AES-256-GCM';
+    /** Key derivation function */
+    keyDerivation: 'PBKDF2';
+    /** Key identifier for key server */
+    keyId: string;
+    /** Whether event chunks are encrypted */
+    encryptedChunks: boolean;
+    /** Whether video/audio is encrypted */
+    encryptedMedia: boolean;
+    /** Initialization vector (base64 encoded) */
+    iv: string;
+}
+/**
+ * Access restrictions for content
+ */
+interface CTAccessRestrictions {
+    /** ISO 8601 expiration date (for rentals) */
+    expiresAt?: string;
+    /** Maximum number of plays allowed */
+    maxPlays?: number;
+    /** Whether user can download for offline viewing */
+    allowDownload: boolean;
+    /** Whether content can be embedded on other sites */
+    allowEmbed: boolean;
+    /** Whitelist of allowed embedding domains */
+    allowedDomains?: string[];
+    /** Whether authentication is required */
+    requireAuth: boolean;
+}
+/**
+ * DRM configuration for premium content
+ */
+interface CTDRMConfig {
+    /** DRM provider to use */
+    provider: CTDRMProvider;
+    /** License acquisition URL */
+    licenseServerUrl: string;
+    /** Certificate URL (required for FairPlay) */
+    certificateUrl?: string;
+}
+/**
+ * Watermark configuration for content tracing
+ */
+interface CTWatermarkConfig {
+    /** Whether watermarking is enabled */
+    enabled: boolean;
+    /** Type of watermark */
+    type: CTWatermarkType;
+    /** Watermark template (e.g., "{userId} - {timestamp}") */
+    data: string;
+}
+/**
+ * Main Access Control Configuration
+ */
+interface CTAccessControl {
+    /** License type */
+    license: CTLicenseType;
+    /** Encryption settings (for private/paid content) */
+    encryption?: CTEncryptionConfig;
+    /** Access restrictions */
+    restrictions?: CTAccessRestrictions;
+    /** DRM configuration (for premium content) */
+    drm?: CTDRMConfig;
+    /** Watermark configuration (for content tracing) */
+    watermark?: CTWatermarkConfig;
+}
+
+/**
+ * CT Format Streaming Types
+ *
+ * Defines types for streaming playback configuration in v1.1.0.
+ * Goal: Start playback within 2 seconds by loading minimal data first.
+ */
+/**
+ * Priority loading configuration
+ */
+interface CTStreamingPriority {
+    /** Files to load FIRST (before playback can start) */
+    critical: string[];
+    /** Files to load SECOND (for smooth early playback) */
+    high: string[];
+    /** Files to prefetch in background */
+    prefetch: string[];
+}
+/**
+ * Buffering strategy configuration
+ */
+interface CTBufferStrategy {
+    /** Minimum buffer before play starts (ms, default: 5000) */
+    minBufferMs: number;
+    /** Maximum buffer to maintain (ms, default: 30000) */
+    maxBufferMs: number;
+    /** Number of chunks to prefetch ahead (default: 2) */
+    prefetchChunks: number;
+}
+/**
+ * Seek optimization configuration
+ */
+interface CTSeekConfig {
+    /** State snapshot interval in ms (default: 60000 = 1 min) */
+    snapshotIntervalMs: number;
+    /** Whether to align seeks to video keyframes */
+    keyframeAligned: boolean;
+}
+/**
+ * Main Streaming Configuration
+ */
+interface CTStreamingConfig {
+    /** Priority loading order */
+    priority: CTStreamingPriority;
+    /** Buffering strategy */
+    buffer: CTBufferStrategy;
+    /** Seek optimization */
+    seeking: CTSeekConfig;
+}
+/**
+ * Recovery information for corrupted files
+ */
+interface CTRecoveryInfo {
+    /** Last chunk that was fully written */
+    lastGoodChunk: number;
+    /** Safe seek points (chunk boundaries) */
+    recoveryPoints: number[];
+}
+/**
+ * File integrity information
+ */
+interface CTIntegrityInfo {
+    /** Hash algorithm used */
+    algorithm: 'SHA-256';
+    /** ISO 8601 timestamp when hashes were generated */
+    generatedAt: string;
+    /** Map of file paths to their SHA-256 hashes */
+    files: Record<string, string>;
+    /** Recovery information */
+    recovery?: CTRecoveryInfo;
+}
+
+/**
+ * Chunked events reference (v1.1.0+)
+ * Events are stored in time-indexed chunks for efficient streaming.
+ */
+interface CTEventsReference {
+    /** Path to chunk index file (e.g., "events/index.json") */
+    indexFile: string;
+    /** Total events across all chunks */
+    totalCount: number;
+    /** Number of chunk files */
+    chunkCount: number;
+    /** Duration per chunk in milliseconds (default: 300000 = 5 min) */
+    chunkDurationMs: number;
+    /** Whether chunks are gzip compressed */
+    compressed: boolean;
+}
+/**
+ * Legacy events reference (v1.0.0)
+ * Single events.json file - kept for backwards compatibility
+ */
+interface CTEventsInfoLegacy {
+    /** Relative path in archive (typically "events.json") */
+    file: string;
+    /** Total number of events */
+    count: number;
+    /** Whether events file is gzip compressed */
+    compressed?: boolean;
+}
+/**
+ * Events info - supports both legacy and chunked formats
+ */
+type CTEventsInfo = CTEventsReference | CTEventsInfoLegacy;
+/**
+ * Author information
+ */
+interface CTAuthorInfo {
+    /** Author's unique ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Email address */
+    email?: string;
+    /** Website URL */
+    url?: string;
+}
+/**
+ * Main manifest structure for a .ct file (v1.1.0)
+ */
+interface CTManifest {
+    /** Format version following semver (e.g., "1.1.0") */
+    formatVersion: string;
+    /** Generator application identifier (e.g., "CT-Courses Recorder v2.1.0") */
+    generator: string;
+    /** Unique identifier for this recording (UUID) */
+    id: string;
+    /** Display title of the recording */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Author information (v1.1.0+) */
+    author?: CTAuthorInfo;
+    /** Total duration in seconds */
+    duration: number;
+    /** ISO 8601 timestamp of creation */
+    createdAt: string;
+    /** ISO 8601 timestamp of last modification */
+    modifiedAt: string;
+    /** Access control and licensing (v1.1.0+) */
+    access?: CTAccessControl;
+    /** Streaming configuration (v1.1.0+) */
+    streaming?: CTStreamingConfig;
+    /** Integrity checksums (v1.1.0+) */
+    integrity?: CTIntegrityInfo;
+    /** Media file references */
+    media: CTMediaInfo;
+    /** Events reference (chunked in v1.1.0+, single file in v1.0.0) */
+    events: CTEventsInfo;
+    /** Chapter/highlight markers */
+    markers: CTMarker[];
+    /** Optional embedded assets */
+    assets?: CTAssets;
+    /** Edit history (for edited recordings) */
+    editHistory?: CTEditHistory;
+    /** Playback configuration hints */
+    playback?: CTPlaybackHints;
+}
+/**
+ * Video segment information for streaming
+ */
+interface CTVideoSegments {
+    /** Segment duration in seconds */
+    duration: number;
+    /** Segment filename pattern (e.g., "media/seg-{index}.webm") */
+    pattern: string;
+    /** Total segment count */
+    count: number;
+}
+/**
+ * Media file references
+ */
+interface CTMediaInfo {
+    video?: CTVideoInfo;
+    audio?: CTAudioInfo;
+    /** Pre-generated waveform for timeline UI (v1.1.0+) */
+    waveform?: CTWaveformInfo;
+}
+/**
+ * Video file metadata
+ */
+interface CTVideoInfo {
+    /** Relative path in archive (e.g., "media/video.webm") */
+    file: string;
+    /** MIME type (e.g., "video/webm", "video/mp4") */
+    mimeType: string;
+    /** Duration in seconds */
+    duration: number;
+    /** Video width in pixels */
+    width: number;
+    /** Video height in pixels */
+    height: number;
+    /** Codec identifier (e.g., "vp9", "h264") */
+    codec?: string;
+    /** Video segments for streaming (v1.1.0+) */
+    segments?: CTVideoSegments;
+    /** Keyframe positions in ms for fast seeking (v1.1.0+) */
+    keyframes?: number[];
+}
+/**
+ * Audio file metadata (when separate from video)
+ */
+interface CTAudioInfo {
+    /** Relative path in archive */
+    file: string;
+    /** MIME type (e.g., "audio/webm", "audio/mp3") */
+    mimeType: string;
+    /** Duration in seconds */
+    duration: number;
+    /** Sample rate in Hz */
+    sampleRate?: number;
+}
+/**
+ * Pre-generated waveform data reference
+ */
+interface CTWaveformInfo {
+    /** Path to waveform file */
+    file: string;
+    /** Samples per second */
+    samplesPerSecond: number;
+}
+/**
+ * Chapter/highlight marker
+ */
+interface CTMarker {
+    /** Unique identifier */
+    id: string;
+    /** Time position in milliseconds */
+    time: number;
+    /** Display label */
+    label: string;
+    /** Marker type */
+    type: CTMarkerType;
+    /** Type-specific additional data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Marker types
+ */
+type CTMarkerType = 'chapter' | 'highlight' | 'quiz' | 'note';
+/**
+ * Embedded assets manifest
+ */
+interface CTAssets {
+    documents?: CTAssetReference[];
+    images?: CTAssetReference[];
+}
+/**
+ * Reference to an embedded asset
+ */
+interface CTAssetReference {
+    /** Unique identifier */
+    id: string;
+    /** Relative path in archive */
+    file: string;
+    /** Display name */
+    name: string;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Edit history for modified recordings
+ */
+interface CTEditHistory {
+    /** Original recording ID */
+    sourceRecordingId: string;
+    /** List of edit operations applied */
+    operations: CTEditOperation[];
+    /** ISO 8601 timestamp of last edit */
+    editedAt: string;
+}
+/**
+ * Edit operation record
+ */
+interface CTEditOperation {
+    /** Unique identifier */
+    id: string;
+    /** Operation type */
+    type: 'cut' | 'trim_start' | 'trim_end' | 'speed';
+    /** Start time in milliseconds (for cut/speed) */
+    startTime?: number;
+    /** End time in milliseconds (for cut/speed) */
+    endTime?: number;
+    /** Amount trimmed in milliseconds (for trims) */
+    trimAmount?: number;
+    /** Speed factor (for speed changes) */
+    factor?: number;
+}
+/**
+ * Playback configuration hints
+ */
+interface CTPlaybackHints {
+    /** Default playback speed (1.0 = normal) */
+    defaultSpeed?: number;
+    /** Whether viewer can edit code when paused */
+    allowInteraction?: boolean;
+    /** Whether to start playing immediately */
+    autoPlay?: boolean;
+}
+/**
+ * Complete recording data structure
+ */
+interface CTRecording {
+    /** Manifest metadata */
+    manifest: CTManifest;
+    /** All events in the recording (flat array) */
+    events: CTEvent[];
+    /** Pre-computed event chunks (v1.1.0+, optional) */
+    chunks?: CTEventChunk[];
+    /** Pre-computed chunk index (v1.1.0+, optional) */
+    chunkIndex?: CTEventChunkIndex;
+    /** State snapshots for fast seeking (v1.1.0+, optional) */
+    snapshots?: StateSnapshot[];
+    /** Video/audio media blob */
+    mediaBlob?: Blob;
+    /** Embedded assets by ID */
+    assets?: Map<string, Blob>;
+}
+
+/**
+ * CT Format Reader
+ *
+ * Parses .ct files (ZIP archives) and extracts all components.
+ * Supports both v1.0.0 (single events.json) and v1.1.0 (chunked events/).
+ */
+
+/**
+ * Options for reading a CT file
+ */
+interface CTReadOptions {
+    /** Whether to load all events immediately (false = lazy loading for chunked)
+     * WARNING: Setting to true can cause memory exhaustion for large files (>100MB)
+     * Use streaming API (streamCTEvents) or lazy loading instead
+     */
+    loadAllEvents?: boolean;
+    /** Validate events after loading */
+    validateEvents?: boolean;
+    /** Whether to load media blobs */
+    loadMedia?: boolean;
+    /** Whether to load assets */
+    loadAssets?: boolean;
+}
+/**
+ * Extended recording type for chunked format
+ */
+interface CTRecordingWithChunks extends CTRecording {
+    /** Chunk index for lazy loading (v1.1.0+) */
+    chunkIndex?: CTEventChunkIndex;
+    /** Function to load a specific chunk (v1.1.0+) */
+    loadChunk?: (chunkNumber: number) => Promise<ChunkLoadResult>;
+    /** Whether events are stored in chunked format */
+    isChunked: boolean;
+}
+/**
+ * Read and parse a .ct file
+ *
+ * @param file - The .ct file as a File, Blob, or ArrayBuffer
+ * @param options - Reading options
+ * @returns Parsed recording data
+ */
+declare function readCTFile(file: File | Blob | ArrayBuffer, options?: CTReadOptions): Promise<CTRecordingWithChunks>;
+/**
+ * Read only the manifest from a .ct file
+ * Faster than full read when you just need metadata
+ */
+declare function readCTManifest(file: File | Blob | ArrayBuffer): Promise<CTManifest>;
+
+/**
+ * CT Format Writer
+ *
+ * Creates .ct files (ZIP archives) from recording data.
+ * Supports both v1.0.0 (single events.json) and v1.1.0 (chunked events/).
+ */
+
+/**
+ * Options for writing a .ct file
+ */
+interface WriteCTOptions {
+    /** Compression level (0-9, default: 6) */
+    compressionLevel?: number;
+    /** Whether to validate before writing (default: true) */
+    validate?: boolean;
+    /** Skip media embedding (useful for draft saves) */
+    skipMedia?: boolean;
+    /** Use chunked events format (v1.1.0+, default: true for large recordings) */
+    useChunkedEvents?: boolean;
+    /** Target events per chunk (default: 1000) */
+    eventsPerChunk?: number;
+    /** Target chunk duration in ms (default: 300000 = 5 minutes) */
+    chunkDurationMs?: number;
+    /** Generate checksums for chunks (default: true) */
+    generateChecksums?: boolean;
+    /** Generate integrity.json for file verification (default: true) */
+    generateIntegrity?: boolean;
+    /** Use SHA-256 for checksums (default: true, falls back to simple hash if unavailable) */
+    useSHA256?: boolean;
+}
+/**
+ * Create a .ct file from recording data
+ *
+ * @param recording - The recording data to package
+ * @param options - Write options
+ * @returns The .ct file as a Blob
+ */
+declare function writeCTFile(recording: CTRecording, options?: WriteCTOptions): Promise<Blob>;
+/**
+ * Create a new empty recording with default manifest
+ */
+declare function createEmptyRecording(name?: string): CTRecording;
+
+/**
+ * CT Format Validator
+ *
+ * Validates .ct file structure and content.
+ * Supports both v1.0.0 (single events) and v1.1.0 (chunked events) formats.
+ */
+
+/**
+ * Validation result
+ */
+interface ValidationResult$1 {
+    /** Whether the validation passed */
+    valid: boolean;
+    /** Error messages (if invalid) */
+    errors?: string[];
+    /** Warning messages (valid but concerning) */
+    warnings?: string[];
+}
+/**
+ * Validate a complete CT recording
+ */
+declare function validateCTFile(recording: CTRecording): ValidationResult$1;
+
+/**
+ * CT-Courses UI Types
+ *
+ * Shared type definitions for all UI components.
+ */
+/**
+ * Component operation mode
+ */
+type PanelMode = 'recording' | 'playback' | 'interactive';
+/**
+ * Base props shared by all panels
+ */
+interface BasePanelProps {
+    /** Current operation mode */
+    mode: PanelMode;
+    /** Whether playback is currently active (playback mode only) */
+    isPlaying?: boolean;
+    /** Called when user interacts during playback */
+    onInteract?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * File system representation
+ */
+interface FileSystemEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'folder' | 'directory';
+    language?: string;
+    children?: FileSystemEntry[];
+}
+/**
+ * Cursor position in editor
+ */
+interface CursorPosition$1 {
+    line: number;
+    column: number;
+}
+/**
+ * Terminal line structure
+ */
+interface TerminalLineData {
+    type: 'input' | 'output' | 'system' | 'error' | 'success' | 'warning' | 'info' | 'header' | 'divider' | 'execution_header' | 'execution_result';
+    text: string;
+    status?: string;
+    time?: number;
+    memory?: number;
+}
+/**
+ * IDE Panel props
+ */
+interface IDEPanelProps extends BasePanelProps {
+    /** Current code content */
+    code?: string;
+    /** Current language */
+    language?: string;
+    /** Current file path */
+    currentFile?: string;
+    /** Cursor position */
+    cursorPosition?: CursorPosition$1;
+    /** Terminal output lines */
+    terminalLines?: TerminalLineData[];
+    /** Current terminal input */
+    terminalInput?: string;
+    /** Called when code changes */
+    onCodeChange?: (code: string, language: string) => void;
+    /** Called when cursor moves */
+    onCursorChange?: (position: CursorPosition$1) => void;
+    /** Called when language changes */
+    onLanguageChange?: (language: string) => void;
+    /** Called when a file is selected */
+    onFileSelect?: (path: string, content: string, language: string) => void;
+    /** Called when file content changes */
+    onFileChange?: (path: string, content: string, language?: string) => void;
+    /** Called when a file is created */
+    onFileCreate?: (path: string, content: string) => void;
+    /** Called when a file is deleted */
+    onFileDelete?: (path: string) => void;
+    /** Called when a file is renamed */
+    onFileRename?: (oldPath: string, newPath: string) => void;
+    /**
+     * File creation state during playback - shows inline input for typing animation.
+     * When set, displays the file creation UI with the inputValue.
+     */
+    fileCreationState?: {
+        type: 'file' | 'folder';
+        parentPath: string;
+        inputValue: string;
+    } | null;
+    /** Called when file creation starts (user clicks New File/Folder button) */
+    onFileCreationStart?: (type: 'file' | 'folder', parentPath: string) => void;
+    /** Called when file creation input changes (user types in the file name input) */
+    onFileCreationInput?: (value: string) => void;
+    /** Called when file creation is cancelled */
+    onFileCreationCancel?: (reason?: string) => void;
+    /** Called when terminal input changes */
+    onTerminalInputChange?: (input: string) => void;
+    /** Called when a command is executed */
+    onTerminalCommand?: (command: string, output: string) => void;
+    /** Called to add lines to terminal */
+    onTerminalAddLines?: (lines: TerminalLineData[]) => void;
+    /** Called when terminal is cleared */
+    onTerminalClear?: () => void;
+    /** Initial file system state */
+    initialFiles?: Record<string, string>;
+    /** Show run code button */
+    showRunButton?: boolean;
+    /** Show file explorer */
+    showFileExplorer?: boolean;
+    /** Default show terminal */
+    defaultShowTerminal?: boolean;
+    /** Default show explorer */
+    defaultShowExplorer?: boolean;
+    /** Read-only editor */
+    readOnly?: boolean;
+    /** Initial active file */
+    initialActiveFile?: string;
+    /** Interactive label text */
+    interactiveLabel?: string;
+    /** Execute code handler */
+    onExecute?: (path: string, language: string) => Promise<TerminalLineData[] | undefined>;
+    /** Execute terminal command handler (uses TerminalService for full command support) */
+    onTerminalExecute?: (command: string) => Promise<TerminalLineData[]>;
+}
+/**
+ * Excalidraw scene structure (simplified)
+ */
+interface WhiteboardScene {
+    elements: unknown[];
+    appState?: Record<string, unknown>;
+    files?: Record<string, unknown>;
+}
+/**
+ * Whiteboard Panel props
+ */
+interface WhiteboardPanelProps extends BasePanelProps {
+    /** Current Excalidraw scene */
+    scene?: WhiteboardScene | null;
+    /** Called when scene changes */
+    onSceneChange?: (scene: WhiteboardScene) => void;
+    /** Called when scene is cleared */
+    onSceneClear?: () => void;
+    /** Show Excalidraw toolbar */
+    showToolbar?: boolean;
+    /** Background color */
+    backgroundColor?: string;
+}
+/**
+ * Document data structure
+ */
+interface DocumentDataInput {
+    /** Unique document ID (for multi-document support) */
+    id?: string;
+    /** Document content (base64, ArrayBuffer, or URL) */
+    data: string | ArrayBuffer;
+    /** Document filename */
+    name: string;
+    /** MIME type */
+    type: string;
+}
+/**
+ * Scroll position
+ */
+interface ScrollPosition {
+    x: number;
+    y: number;
+}
+/**
+ * Document info returned on load
+ */
+interface DocumentInfo {
+    id?: string;
+    data: string;
+    name: string;
+    numPages: number;
+    type: string;
+}
+/**
+ * Document Panel props
+ */
+interface DocumentPanelProps extends BasePanelProps {
+    /** Document data (single document - for backwards compatibility) */
+    documentData?: DocumentDataInput | null;
+    /** Multiple documents (new multi-document support) */
+    documents?: DocumentDataInput[];
+    /** Currently active document ID (for multi-document mode) */
+    activeDocumentId?: string;
+    /** Current page number (1-indexed) */
+    currentPage?: number;
+    /** Zoom level (1.0 = 100%) */
+    zoom?: number;
+    /** Scroll position within page */
+    scrollPosition?: ScrollPosition;
+    /** Called when document is loaded */
+    onDocumentLoad?: (info: DocumentInfo) => void;
+    /** Called when active document changes (multi-document mode) */
+    onDocumentSelect?: (documentId: string) => void;
+    /** Called when a document is removed (multi-document mode) */
+    onDocumentRemove?: (documentId: string) => void;
+    /** Called when page changes */
+    onPageChange?: (page: number) => void;
+    /** Called when zoom changes */
+    onZoomChange?: (zoom: number) => void;
+    /** Called when scroll position changes */
+    onScrollChange?: (position: ScrollPosition) => void;
+    /** Called when document is cleared */
+    onDocumentClear?: () => void;
+    /** Show document tab bar (for multiple documents) */
+    showTabBar?: boolean;
+    /** Show navigation toolbar */
+    showToolbar?: boolean;
+    /** Show page indicator */
+    showPageIndicator?: boolean;
+    /** Allow file upload */
+    allowUpload?: boolean;
+    /** Allow multiple document uploads */
+    allowMultiple?: boolean;
+    /** Background color */
+    backgroundColor?: string;
+}
+/**
+ * Terminal component props
+ */
+interface TerminalProps {
+    /** Output lines */
+    lines?: TerminalLineData[];
+    /** Current input value */
+    input?: string;
+    /** Called when input changes */
+    onInputChange?: (value: string) => void;
+    /** Called when command is submitted */
+    onCommand?: (command: string) => void;
+    /** Called when terminal is cleared (Ctrl+L) */
+    onClear?: () => void;
+    /** Is code currently executing */
+    isExecuting?: boolean;
+    /** Read-only mode */
+    isReadOnly?: boolean;
+    /** Input placeholder */
+    placeholder?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Show prompt */
+    showPrompt?: boolean;
+    /** Auto-focus input */
+    autoFocus?: boolean;
+}
+/**
+ * Terminal ref interface
+ */
+interface TerminalRef {
+    focus: () => void;
+    scrollToBottom: () => void;
+}
+/**
+ * File Explorer props
+ */
+interface FileExplorerProps {
+    /** Currently selected file path */
+    selectedFile?: string | null;
+    /** Called when file is selected */
+    onFileSelect: (path: string) => void;
+    /** Called when file is created */
+    onFileCreate?: (path: string, content: string) => void;
+    /** Called when folder is created */
+    onFolderCreate?: (path: string) => void;
+    /** Called when file is deleted */
+    onFileDelete?: (path: string) => void;
+    /** Called when file is renamed */
+    onFileRename?: (oldPath: string, newPath: string) => void;
+    /** Called when user starts creating a file/folder (clicks New File/Folder button) */
+    onFileCreationStart?: (type: 'file' | 'folder', parentPath: string) => void;
+    /** Called when user types in the file creation input */
+    onFileCreationInput?: (value: string) => void;
+    /** Called when user cancels file creation (Escape or blur) */
+    onFileCreationCancel?: (reason?: string) => void;
+    /**
+     * Playback file creation state - for showing the file creation input during playback.
+     * When set, displays a read-only input showing the filename being typed.
+     */
+    playbackFileCreation?: {
+        type: 'file' | 'folder';
+        parentPath: string;
+        inputValue: string;
+    } | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * Available tool types
+ */
+type ToolType = 'code' | 'whiteboard' | 'document';
+/**
+ * Tool Sidebar props
+ */
+interface ToolSidebarProps {
+    /** Currently active tool */
+    activeTool: ToolType;
+    /** Called when tool changes */
+    onToolChange: (tool: ToolType) => void;
+    /** Available tools */
+    tools?: ToolType[];
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function ToolSidebar({ activeTool, onToolChange, tools, className, }: ToolSidebarProps): react_jsx_runtime.JSX.Element;
+
+declare function WhiteboardPanel({ scene, onSceneChange, onSceneClear, mode, isPlaying, onInteract, showToolbar, backgroundColor, className, }: WhiteboardPanelProps): react_jsx_runtime.JSX.Element;
+
+declare function DocumentPanel({ documentData, documents: externalDocuments, activeDocumentId: externalActiveId, currentPage, zoom, scrollPosition, onDocumentLoad, onDocumentSelect, onDocumentRemove, onPageChange, onZoomChange, onScrollChange, onDocumentClear, mode, isPlaying, onInteract, showTabBar, showToolbar, showPageIndicator, allowUpload, allowMultiple, backgroundColor, className, }: DocumentPanelProps): react_jsx_runtime.JSX.Element;
+
+interface VirtualFileSystem {
+    getFileTree: () => FileSystemEntry;
+    subscribe: (callback: () => void) => () => void;
+    writeFile: (path: string, content: string) => void;
+    /** Optional: Read file content by path */
+    readFile?: (path: string) => string;
+    /** Optional: Get all files as a record */
+    getFiles?: () => Record<string, string>;
+}
+declare function FileExplorer({ fileSystem, selectedFile, onFileSelect, onFileCreate, onFolderCreate, onFileDelete, onFileRename, onFileCreationStart, onFileCreationInput, onFileCreationCancel, playbackFileCreation, className }: FileExplorerProps & {
+    fileSystem: VirtualFileSystem;
+}): react_jsx_runtime.JSX.Element;
+
+declare function IDEPanel({ fileSystem, code: externalCode, language: externalLanguage, currentFile: externalCurrentFile, onCodeChange, onFileChange, onFileCreate, onFileDelete, onFileRename, onFileSelect, onTerminalCommand, onTerminalClear, onTerminalAddLines, fileCreationState, onFileCreationStart, onFileCreationInput, onFileCreationCancel, terminalLines: externalTerminalLines, terminalInput: externalTerminalInput, onTerminalInputChange, onExecute, onTerminalExecute, mode, isPlaying, defaultShowExplorer, defaultShowTerminal, showRunButton, interactiveLabel, initialFiles, initialActiveFile }: IDEPanelProps & {
+    fileSystem: VirtualFileSystem;
+}): react_jsx_runtime.JSX.Element;
+
+declare const Terminal: react.ForwardRefExoticComponent<TerminalProps & react.RefAttributes<TerminalRef>>;
+
+/**
+ * Active tool type - matches ToolType from @ct-courses/ui
+ */
+type ActiveTool$1 = 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 */
+    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;
+}
+/**
+ * Imperative handle for CoursePlayer
+ */
+interface CoursePlayerRef {
+    play(): void;
+    pause(): void;
+    seek(timeMs: number): void;
+    setSpeed(speed: number): void;
+    getCurrentTime(): number;
+    getDuration(): number;
+    getState(): PlaybackState$1;
+    enterInteractiveMode(): void;
+    exitInteractiveMode(): void;
+    setActiveTool(tool: ActiveTool$1): void;
+}
+/**
+ * CoursePlayer component
+ */
+declare const CoursePlayer: react.ForwardRefExoticComponent<CoursePlayerProps & react.RefAttributes<CoursePlayerRef>>;
+
+/**
+ * CT-Courses Player - Remote Streaming Types
+ *
+ * Types for streaming playback from a remote CDN/R2 storage.
+ * These types match the streaming service manifest structure.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Audio quality level information
+ */
+interface AudioQuality {
+    /** Quality name (low, medium, high) */
+    name: string;
+    /** Bitrate in bits per second */
+    bitrate: number;
+    /** URL to the quality-specific playlist */
+    playlistUrl: string;
+}
+/**
+ * Recording metadata from the streaming manifest
+ */
+interface StreamingRecordingInfo {
+    /** Recording ID */
+    id: string;
+    /** Recording name/title */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Creation timestamp (ISO 8601) */
+    createdAt: string;
+}
+/**
+ * Audio streaming configuration
+ */
+interface StreamingAudioConfig {
+    /** Audio type (always 'hls' for adaptive streaming) */
+    type: 'hls';
+    /** URL to the HLS master playlist */
+    masterPlaylistUrl: string;
+    /** Available quality levels */
+    qualities: AudioQuality[];
+    /** Audio duration in seconds */
+    duration: number;
+}
+/**
+ * Events streaming configuration
+ */
+interface StreamingEventsConfig {
+    /** URL to the events chunk index */
+    indexUrl: string;
+    /** Total number of event chunks */
+    totalChunks: number;
+    /** Total event count */
+    totalEvents: number;
+    /** Duration of each chunk in milliseconds */
+    chunkDurationMs: number;
+    /** Whether chunks are gzip compressed */
+    compressed: boolean;
+}
+/**
+ * Streaming playback configuration hints
+ */
+interface StreamingConfig {
+    /** Number of chunks to prefetch ahead */
+    prefetchChunks: number;
+    /** Minimum buffer before play starts (ms) */
+    minBufferMs: number;
+    /** Maximum buffer to maintain (ms) */
+    maxBufferMs: number;
+}
+/**
+ * Complete streaming manifest structure
+ * This is the main entry point returned by the streaming service.
+ */
+interface StreamingManifest {
+    /** Manifest version */
+    version: string;
+    /** Content ID */
+    contentId: string;
+    /** Recording metadata */
+    recording: StreamingRecordingInfo;
+    /** Audio streaming configuration */
+    audio: StreamingAudioConfig;
+    /** Events streaming configuration */
+    events: StreamingEventsConfig;
+    /** Streaming playback hints */
+    streaming: StreamingConfig;
+}
+/**
+ * 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
+ */
+interface RemoteBufferHealth {
+    /** Current buffer status */
+    status: 'healthy' | 'buffering' | 'critical' | 'empty';
+    /** Number of chunks currently cached */
+    cachedChunks: number;
+    /** Total number of chunks */
+    totalChunks: number;
+    /** Current chunk being played */
+    currentChunk: number;
+    /** 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 */
+    isReady: 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;
+}
+/**
+ * HLS player configuration
+ */
+interface HLSPlayerConfig {
+    /** Max buffer length in seconds */
+    maxBufferLength?: number;
+    /** Max max buffer length in seconds */
+    maxMaxBufferLength?: number;
+    /** Start level (-1 for auto) */
+    startLevel?: number;
+    /** Auto-start load */
+    autoStartLoad?: boolean;
+}
+/**
+ * HLS quality level info
+ */
+interface HLSQualityLevel {
+    /** Level index */
+    index: number;
+    /** Bitrate */
+    bitrate: number;
+    /** Codec string */
+    codecs: string;
+}
+
+type ActiveTool = 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 */
+    maxCacheSize?: number;
+    /** Additional CSS class */
+    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;
+}
+/**
+ * Imperative handle for StreamingCoursePlayer
+ */
+interface StreamingCoursePlayerRef {
+    play(): void;
+    pause(): void;
+    seek(timeMs: number): Promise<void>;
+    setSpeed(speed: number): void;
+    getCurrentTime(): number;
+    getDuration(): number;
+    getState(): PlaybackState$1;
+    setActiveTool(tool: ActiveTool): void;
+    getManifest(): StreamingManifest | null;
+    getBufferHealth(): RemoteBufferHealth;
+}
+declare const StreamingCoursePlayer: react.ForwardRefExoticComponent<StreamingCoursePlayerProps & react.RefAttributes<StreamingCoursePlayerRef>>;
+
+/**
+ * @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;
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    playbackSpeed: number;
+    volume: number;
+    muted: boolean;
+    code: string;
+    language: string;
+    terminalLines: TerminalLineData[];
+    terminalInput: string;
+    strokes: unknown[];
+    excalidrawScene: ExcalidrawScene | null;
+    activeTool: ToolType;
+    markers: RecordingMarker[];
+    currentFile: string | null;
+    fileSystemSnapshot: FileSystemSnapshot;
+    cursorPosition: CursorPosition;
+    documentData: PlayerDocumentData | null;
+    documentPage: number;
+    documentZoom: number;
+    documentScroll: ScrollPosition;
+    mediaUrl: string | null;
+    isInteracting: boolean;
+}
+/**
+ * Playback controls
+ */
+interface PlaybackControls$1 {
+    setAudioElement: (element: HTMLAudioElement | null) => void;
+    setVolume: (volume: number) => void;
+    setMuted: (muted: boolean) => void;
+    play: () => void;
+    pause: () => void;
+    togglePlay: () => void;
+    seekTo: (timeSeconds: number) => void;
+    skip: (seconds: number) => void;
+    restart: () => void;
+    setSpeed: (speed: number) => void;
+    enterInteractiveMode: () => void;
+    interactiveSetCode: (code: string) => void;
+    interactiveSetLanguage: (language: string) => void;
+    interactiveSetTerminalInput: (input: string) => void;
+    interactiveSetTerminalLines: (lines: TerminalLineData[]) => void;
+    interactiveAddTerminalLines: (lines: TerminalLineData[]) => void;
+    interactiveSetStrokes: (strokes: unknown[]) => void;
+    interactiveSetExcalidrawScene: (scene: ExcalidrawScene | null) => void;
+    interactiveSetDocumentPage: (page: number) => void;
+    interactiveSetDocumentZoom: (zoom: number) => void;
+    interactiveSetDocumentScroll: (scroll: ScrollPosition) => void;
+    setActiveTool: (tool: ToolType) => void;
+}
+/**
+ * Full playback engine result
+ */
+type UsePlaybackEngineResult = PlaybackState & PlaybackControls$1;
+/**
+ * Player component props
+ */
+interface PlayerProps {
+    ctFile?: Blob;
+    recording?: CTRecording;
+    recordingId?: string;
+    backendAdapter?: BackendAdapter;
+    autoPlay?: boolean;
+    showControls?: boolean;
+    showTimeline?: boolean;
+    showToolSidebar?: boolean;
+    showAudio?: boolean;
+    defaultSpeed?: number;
+    allowInteraction?: boolean;
+    theme?: 'light' | 'dark' | 'system';
+    className?: string;
+    onReady?: () => void;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onEnded?: () => void;
+    onTimeUpdate?: (time: number) => void;
+    onError?: (error: Error) => void;
+    onInteractionStart?: () => void;
+    onInteractionEnd?: (code: string) => void;
+}
+/**
+ * Player imperative handle
+ */
+interface PlayerRef {
+    play(): void;
+    pause(): void;
+    seek(timeMs: number): void;
+    setSpeed(speed: number): void;
+    getCurrentTime(): number;
+    getDuration(): number;
+    enterInteractiveMode(): void;
+    exitInteractiveMode(): void;
+    setActiveTool(tool: ToolType): void;
+}
+/**
+ * PlayerControls props
+ */
+interface PlayerControlsProps$1 {
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    playbackSpeed: number;
+    volume: number;
+    muted: boolean;
+    isInteracting: boolean;
+    onPlay: () => void;
+    onPause: () => void;
+    onSeek: (time: number) => void;
+    onSpeedChange: (speed: number) => void;
+    onVolumeChange: (volume: number) => void;
+    onMuteToggle: () => void;
+    className?: string;
+}
+/**
+ * Timeline props
+ */
+interface TimelineProps$1 {
+    currentTime: number;
+    duration: number;
+    markers?: RecordingMarker[];
+    buffered?: Array<{
+        start: number;
+        end: number;
+    }>;
+    onSeek: (time: number) => void;
+    onMarkerClick?: (marker: RecordingMarker) => void;
+    className?: string;
+}
+/**
+ * Speed selector props
+ */
+interface SpeedSelectorProps {
+    speed: number;
+    onSpeedChange: (speed: number) => void;
+    speeds?: number[];
+    className?: string;
+}
+/**
+ * Volume control props
+ */
+interface VolumeControlProps {
+    volume: number;
+    muted: boolean;
+    onVolumeChange: (volume: number) => void;
+    onMuteToggle: () => void;
+    className?: string;
+}
+
+/**
+ * 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;
+    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;
+}
+/**
+ * Options for usePlayback hook
+ */
+interface UsePlaybackOptions {
+    recording: CTRecording | null;
+    autoPlay?: boolean;
+    defaultSpeed?: number;
+    defaultVolume?: number;
+    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.MutableRefObject<HTMLAudioElement | null>;
+    isLoaded: boolean;
+    error: Error | null;
+    duration: number;
+};
+/** @deprecated Use AudioSyncState instead */
+type VideoSyncState = AudioSyncState;
+/** @deprecated Use AudioSyncControls instead */
+type VideoSyncControls = AudioSyncControls;
+/** @deprecated Use UseAudioSyncOptions instead */
+type UseVideoSyncOptions = UseAudioSyncOptions;
+/** @deprecated Use useAudioSync instead */
+declare const useVideoSync: typeof useAudioSync;
+/** @deprecated Use useAudioElement instead */
+declare const useVideoElement: typeof useAudioElement;
+
+/**
+ * HLS Loader Utility
+ *
+ * Wrapper around HLS.js for adaptive audio streaming.
+ * Handles both native HLS support (Safari) and HLS.js polyfill.
+ *
+ * @packageDocumentation
+ */
+
+interface HLSPlayerInstance {
+    /** The HLS.js instance (null if using native HLS) */
+    hls: Hls | null;
+    /** The audio element */
+    audioElement: HTMLAudioElement;
+    /** Whether this is using native HLS (Safari) */
+    isNative: boolean;
+    /** Destroy and cleanup */
+    destroy: () => void;
+    /** Get current quality levels */
+    getQualityLevels: () => HLSQualityLevel[];
+    /** Set quality level (-1 for auto) */
+    setQualityLevel: (index: number) => void;
+    /** Get current quality level */
+    getCurrentQualityLevel: () => number;
+    /** Add event listener for HLS events */
+    on: (event: string, callback: (...args: unknown[]) => void) => void;
+    /** Remove event listener */
+    off: (event: string, callback: (...args: unknown[]) => void) => void;
+}
+interface HLSEvents {
+    /** Manifest has been parsed and is ready */
+    MANIFEST_PARSED: 'hlsManifestParsed';
+    /** Level has switched */
+    LEVEL_SWITCHED: 'hlsLevelSwitched';
+    /** Error occurred */
+    ERROR: 'hlsError';
+    /** Buffering started */
+    BUFFER_CREATED: 'hlsBufferCreated';
+    /** Fragment loaded */
+    FRAG_LOADED: 'hlsFragLoaded';
+}
+declare const HLS_EVENTS: HLSEvents;
+/**
+ * Check if the browser supports HLS.js
+ */
+declare function isHlsSupported(): boolean;
+/**
+ * Check if the browser has native HLS support (Safari)
+ */
+declare function hasNativeHlsSupport(): boolean;
+/**
+ * Check if any form of HLS playback is possible
+ */
+declare function canPlayHls(): boolean;
+/**
+ * Create an HLS player instance
+ *
+ * @param audioElement - The audio element to attach to
+ * @param masterPlaylistUrl - URL to the HLS master playlist
+ * @param config - Optional configuration
+ * @returns HLS player instance
+ * @throws Error if HLS is not supported
+ */
+declare function createHlsPlayer(audioElement: HTMLAudioElement, masterPlaylistUrl: string, config?: HLSPlayerConfig): HLSPlayerInstance;
+/**
+ * Destroy an HLS player instance safely
+ */
+declare function destroyHlsPlayer(player: HLSPlayerInstance | null): void;
+
+interface Marker$1 {
+    time: number;
+    label?: string;
+    type?: 'chapter' | 'highlight';
+}
+interface PlayerControlsProps {
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    volume: number;
+    muted: boolean;
+    playbackSpeed: number;
+    markers?: Marker$1[];
+    isFullscreen?: boolean;
+    onPlayPause: () => void;
+    onSeek: (timeMs: number) => void;
+    onSeekStart?: () => void;
+    onSeekEnd?: () => void;
+    onSkip: (seconds: number) => void;
+    onRestart: () => void;
+    onVolumeChange: (volume: number) => void;
+    onMuteToggle: () => void;
+    onSpeedChange: (speed: number) => void;
+    onFullscreenToggle?: () => void;
+    showMarkers?: boolean;
+    compact?: boolean;
+    containerRef?: react__default.RefObject<HTMLElement>;
+}
+declare function PlayerControls({ isPlaying, currentTime, duration, volume, muted, playbackSpeed, markers, isFullscreen, onPlayPause, onSeek, onSeekStart, onSeekEnd, onSkip, onRestart, onVolumeChange, onMuteToggle, onSpeedChange, onFullscreenToggle, showMarkers, compact, }: PlayerControlsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Timeline Component
+ *
+ * Enhanced visual timeline with markers, chunk indicators, and chapter navigation.
+ * Supports streaming playback visualization and buffer status.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Timeline marker
+ */
+interface Marker {
+    id: string;
+    time: number;
+    label: string;
+    type: 'chapter' | 'highlight' | 'quiz' | 'note' | 'bookmark' | 'error';
+    description?: string;
+}
+/**
+ * Chunk info for streaming visualization
+ */
+interface ChunkInfo {
+    id: number;
+    startTime: number;
+    endTime: number;
+    loaded: boolean;
+    loading?: boolean;
+    size?: number;
+}
+/**
+ * Buffered range
+ */
+interface BufferedRange {
+    start: number;
+    end: number;
+}
+/**
+ * Props for Timeline component
+ */
+interface TimelineProps {
+    /** Current time in ms */
+    currentTime: number;
+    /** Total duration in ms */
+    duration: number;
+    /** Timeline markers */
+    markers?: Marker[];
+    /** Chunk info for streaming visualization */
+    chunks?: ChunkInfo[];
+    /** Buffered ranges */
+    buffered?: BufferedRange[];
+    /** Seek callback */
+    onSeek: (timeMs: number) => void;
+    /** Marker click callback */
+    onMarkerClick?: (marker: Marker) => void;
+    /** Theme */
+    theme?: 'light' | 'dark';
+    /** Show chapter labels */
+    showChapterLabels?: boolean;
+    /** Show buffer status */
+    showBufferStatus?: boolean;
+    /** Show chunk indicators */
+    showChunkIndicators?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+}
+/**
+ * Timeline component with markers and chunk indicators
+ */
+declare function Timeline({ currentTime, duration, markers, chunks, buffered, onSeek, onMarkerClick, theme, showChapterLabels, showBufferStatus, showChunkIndicators, compact, }: TimelineProps): JSX.Element;
+
+/**
+ * AudioOverlay Component
+ *
+ * Audio playback overlay with controls and visualization.
+ * Replaces WebcamOverlay for audio-only playback.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Overlay position presets
+ */
+type OverlayPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'custom';
+/**
+ * Custom position
+ */
+interface CustomPosition {
+    x: number;
+    y: number;
+}
+/**
+ * Props for AudioOverlay component
+ */
+interface AudioOverlayProps {
+    /** Audio source URL */
+    src: string | null;
+    /** Current time to sync to (ms) */
+    currentTime: number;
+    /** Whether audio should be playing */
+    isPlaying: boolean;
+    /** Playback rate */
+    playbackRate?: number;
+    /** Overlay position preset */
+    position?: OverlayPosition;
+    /** Custom position (when position='custom') */
+    customPosition?: CustomPosition;
+    /** Whether to show the overlay */
+    visible?: boolean;
+    /** Enable dragging */
+    draggable?: boolean;
+    /** Show controls on hover */
+    showControls?: boolean;
+    /** Opacity (0-1) */
+    opacity?: number;
+    /** On position change callback */
+    onPositionChange?: (position: CustomPosition) => void;
+    /** Callback to pass audio element reference for sync */
+    onAudioRef?: (audio: HTMLAudioElement | null) => void;
+    /** Whether audio is muted */
+    muted?: boolean;
+    /** Volume level (0-1) */
+    volume?: number;
+    /** Sync tolerance in ms */
+    syncTolerance?: number;
+}
+/**
+ * Audio overlay for instructor audio
+ *
+ * NOTE: Audio playback is now controlled entirely by parent (usePlayback).
+ * Props like currentTime, isPlaying, playbackRate, muted, volume, syncTolerance
+ * are kept for backward compatibility but are no longer used.
+ */
+declare function AudioOverlay({ src, currentTime: _currentTime, isPlaying: _isPlaying, playbackRate: _playbackRate, position, customPosition, visible, draggable, showControls, opacity, onPositionChange, onAudioRef, muted: _muted, volume: _volume, syncTolerance: _syncTolerance, }: AudioOverlayProps): JSX.Element | null;
+
+export { AudioOverlay, type AudioOverlayProps, type AudioQuality, type AudioSyncControls, type AudioSyncState, type BackendAdapter, type BufferHealth, type CTEvent, type CTManifest, type CTMarker, type CTReadOptions, type CTRecording, CoursePlayer, type CoursePlayerProps, type CoursePlayerRef, type CursorPosition, type CustomPosition, DocumentPanel, type DocumentPanelProps, FileExplorer, type FileExplorerProps, type FileSystemSnapshot, type HLSPlayerInstance, HLS_EVENTS, IDEPanel, type IDEPanelProps, type InternalEvent, type InternalRecording, type 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, 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, type UseAudioSyncOptions, type UsePlaybackEngineResult, type UsePlaybackOptions, type UseRemoteStreamingPlaybackOptions, type UseVideoSyncOptions, type ValidationResult$1 as ValidationResult, type VideoSyncControls, type VideoSyncState, type VolumeControlProps, AudioOverlay as WebcamOverlay, type AudioOverlayProps as WebcamOverlayProps, WhiteboardPanel, type WhiteboardPanelProps, type WriteCTOptions, canPlayHls, createEmptyRecording, createHlsPlayer, destroyHlsPlayer, hasNativeHlsSupport, isHlsSupported, readCTFile, readCTManifest, useAudioElement, useAudioSync, useInteractiveMode, usePlayback, usePlayback as usePlaybackEngine, useRemoteStreamingPlayback, useStreamingPlayback, useVideoElement, useVideoSync, validateCTFile, writeCTFile };