markupr 2.1.8

package/dist/preload/index.mjs

@@ -0,0 +1,907 @@
+import { contextBridge, ipcRenderer } from "electron";
+const IPC_CHANNELS = {
+  // ---------------------------------------------------------------------------
+  // Session Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  SESSION_START: "markupr:session:start",
+  SESSION_STOP: "markupr:session:stop",
+  SESSION_PAUSE: "markupr:session:pause",
+  SESSION_RESUME: "markupr:session:resume",
+  SESSION_CANCEL: "markupr:session:cancel",
+  SESSION_GET_STATUS: "markupr:session:get-status",
+  SESSION_GET_CURRENT: "markupr:session:get-current",
+  // ---------------------------------------------------------------------------
+  // Session Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  SESSION_STATE_CHANGED: "markupr:session:state-changed",
+  SESSION_STATUS: "markupr:session:status-update",
+  SESSION_COMPLETE: "markupr:session:complete",
+  SESSION_FEEDBACK_ITEM: "markupr:session:feedback-item",
+  SESSION_VOICE_ACTIVITY: "markupr:session:voice-activity",
+  SESSION_ERROR: "markupr:session:error",
+  // ---------------------------------------------------------------------------
+  // Capture Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  CAPTURE_GET_SOURCES: "markupr:capture:get-sources",
+  CAPTURE_MANUAL_SCREENSHOT: "markupr:capture:manual-screenshot",
+  SCREEN_RECORDING_START: "markupr:screen-recording:start",
+  SCREEN_RECORDING_CHUNK: "markupr:screen-recording:chunk",
+  SCREEN_RECORDING_STOP: "markupr:screen-recording:stop",
+  // ---------------------------------------------------------------------------
+  // Capture Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  SCREENSHOT_CAPTURED: "markupr:capture:screenshot-taken",
+  MANUAL_SCREENSHOT: "markupr:capture:manual-triggered",
+  // ---------------------------------------------------------------------------
+  // Audio Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  AUDIO_GET_DEVICES: "markupr:audio:get-devices",
+  AUDIO_SET_DEVICE: "markupr:audio:set-device",
+  // ---------------------------------------------------------------------------
+  // Audio Channels (Main -> Renderer) - Communication with audio capture
+  // ---------------------------------------------------------------------------
+  AUDIO_REQUEST_DEVICES: "markupr:audio:request-devices",
+  AUDIO_START_CAPTURE: "markupr:audio:start-capture",
+  AUDIO_STOP_CAPTURE: "markupr:audio:stop-capture",
+  AUDIO_CHUNK: "markupr:audio:chunk",
+  AUDIO_DEVICES_RESPONSE: "markupr:audio:devices-response",
+  AUDIO_CAPTURE_ERROR: "markupr:audio:capture-error",
+  AUDIO_CAPTURE_STARTED: "markupr:audio:capture-started",
+  AUDIO_CAPTURE_STOPPED: "markupr:audio:capture-stopped",
+  AUDIO_LEVEL: "markupr:audio:level",
+  AUDIO_VOICE_ACTIVITY: "markupr:audio:voice-activity",
+  // ---------------------------------------------------------------------------
+  // Transcription Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  TRANSCRIPTION_UPDATE: "markupr:transcript:chunk",
+  TRANSCRIPTION_FINAL: "markupr:transcript:final",
+  // ---------------------------------------------------------------------------
+  // Transcription Control Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  TRANSCRIPTION_GET_TIER_STATUSES: "markupr:transcription:get-tier-statuses",
+  TRANSCRIPTION_GET_CURRENT_TIER: "markupr:transcription:get-current-tier",
+  TRANSCRIPTION_SET_TIER: "markupr:transcription:set-tier",
+  // ---------------------------------------------------------------------------
+  // Settings Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  SETTINGS_GET: "markupr:settings:get",
+  SETTINGS_GET_ALL: "markupr:settings:get-all",
+  SETTINGS_SET: "markupr:settings:set",
+  SETTINGS_GET_API_KEY: "markupr:settings:get-api-key",
+  SETTINGS_SET_API_KEY: "markupr:settings:set-api-key",
+  SETTINGS_DELETE_API_KEY: "markupr:settings:delete-api-key",
+  SETTINGS_HAS_API_KEY: "markupr:settings:has-api-key",
+  SETTINGS_TEST_API_KEY: "markupr:settings:test-api-key",
+  SETTINGS_SELECT_DIRECTORY: "markupr:settings:select-directory",
+  SETTINGS_CLEAR_ALL_DATA: "markupr:settings:clear-all-data",
+  SETTINGS_EXPORT: "markupr:settings:export",
+  SETTINGS_IMPORT: "markupr:settings:import",
+  // ---------------------------------------------------------------------------
+  // Permissions Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  PERMISSIONS_CHECK: "markupr:permissions:check",
+  PERMISSIONS_REQUEST: "markupr:permissions:request",
+  PERMISSIONS_GET_ALL: "markupr:permissions:get-all",
+  // ---------------------------------------------------------------------------
+  // Output Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  OUTPUT_SAVE: "markupr:output:save",
+  OUTPUT_COPY_CLIPBOARD: "markupr:output:copy-clipboard",
+  OUTPUT_OPEN_FOLDER: "markupr:output:open-folder",
+  // Session History Browser
+  OUTPUT_LIST_SESSIONS: "markupr:output:list-sessions",
+  OUTPUT_GET_SESSION_METADATA: "markupr:output:get-session-metadata",
+  OUTPUT_DELETE_SESSION: "markupr:output:delete-session",
+  OUTPUT_DELETE_SESSIONS: "markupr:output:delete-sessions",
+  OUTPUT_EXPORT_SESSION: "markupr:output:export-session",
+  OUTPUT_EXPORT_SESSIONS: "markupr:output:export-sessions",
+  // ---------------------------------------------------------------------------
+  // Output Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  OUTPUT_READY: "markupr:output:ready",
+  OUTPUT_ERROR: "markupr:output:error",
+  // ---------------------------------------------------------------------------
+  // Hotkey Channels
+  // ---------------------------------------------------------------------------
+  HOTKEY_TRIGGERED: "markupr:hotkey:triggered",
+  HOTKEY_CONFIG: "markupr:hotkey:config",
+  HOTKEY_UPDATE: "markupr:hotkey:update",
+  // ---------------------------------------------------------------------------
+  // Clipboard (Legacy - kept for compatibility)
+  // ---------------------------------------------------------------------------
+  COPY_TO_CLIPBOARD: "markupr:clipboard:copy",
+  // ---------------------------------------------------------------------------
+  // Window Control Channels
+  // ---------------------------------------------------------------------------
+  WINDOW_MINIMIZE: "markupr:window:minimize",
+  WINDOW_CLOSE: "markupr:window:close",
+  WINDOW_HIDE: "markupr:window:hide",
+  // ---------------------------------------------------------------------------
+  // Update Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  UPDATE_CHECK: "markupr:update:check",
+  UPDATE_DOWNLOAD: "markupr:update:download",
+  UPDATE_INSTALL: "markupr:update:install",
+  // ---------------------------------------------------------------------------
+  // Update Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  UPDATE_STATUS: "markupr:update:status",
+  // ---------------------------------------------------------------------------
+  // Crash Recovery Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  CRASH_RECOVERY_CHECK: "markupr:crash-recovery:check",
+  CRASH_RECOVERY_RECOVER: "markupr:crash-recovery:recover",
+  CRASH_RECOVERY_DISCARD: "markupr:crash-recovery:discard",
+  CRASH_RECOVERY_GET_LOGS: "markupr:crash-recovery:get-logs",
+  CRASH_RECOVERY_CLEAR_LOGS: "markupr:crash-recovery:clear-logs",
+  CRASH_RECOVERY_UPDATE_SETTINGS: "markupr:crash-recovery:update-settings",
+  // ---------------------------------------------------------------------------
+  // Crash Recovery Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  CRASH_RECOVERY_FOUND: "markupr:crash-recovery:found",
+  // ---------------------------------------------------------------------------
+  // Whisper Model Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  WHISPER_CHECK_MODEL: "markupr:whisper:check-model",
+  WHISPER_DOWNLOAD_MODEL: "markupr:whisper:download-model",
+  WHISPER_CANCEL_DOWNLOAD: "markupr:whisper:cancel-download",
+  WHISPER_GET_AVAILABLE_MODELS: "markupr:whisper:get-available-models",
+  WHISPER_HAS_TRANSCRIPTION_CAPABILITY: "markupr:whisper:has-transcription-capability",
+  // ---------------------------------------------------------------------------
+  // Whisper Model Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  WHISPER_DOWNLOAD_PROGRESS: "markupr:whisper:download-progress",
+  WHISPER_DOWNLOAD_COMPLETE: "markupr:whisper:download-complete",
+  WHISPER_DOWNLOAD_ERROR: "markupr:whisper:download-error",
+  // ---------------------------------------------------------------------------
+  // Processing Pipeline Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  PROCESSING_PROGRESS: "markupr:processing:progress",
+  PROCESSING_COMPLETE: "markupr:processing:complete",
+  // ---------------------------------------------------------------------------
+  // Navigation Channels (Main -> Renderer)
+  // ---------------------------------------------------------------------------
+  SHOW_ONBOARDING: "markupr:show-onboarding",
+  SHOW_SETTINGS: "markupr:show-settings",
+  SHOW_HISTORY: "markupr:show-history",
+  SHOW_EXPORT: "markupr:show-export",
+  SHOW_SHORTCUTS: "markupr:show-shortcuts",
+  SHOW_WINDOW_SELECTOR: "markupr:show-window-selector",
+  // ---------------------------------------------------------------------------
+  // App Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  APP_VERSION: "markupr:app:version",
+  // ---------------------------------------------------------------------------
+  // Popover Channels (Renderer -> Main)
+  // ---------------------------------------------------------------------------
+  POPOVER_RESIZE: "markupr:popover:resize",
+  POPOVER_RESIZE_TO_STATE: "markupr:popover:resize-to-state",
+  // ---------------------------------------------------------------------------
+  // Legacy channels (backwards compatibility)
+  // ---------------------------------------------------------------------------
+  START_SESSION: "session:start",
+  STOP_SESSION: "session:stop",
+  GET_SETTINGS: "settings:get",
+  SET_SETTINGS: "settings:set"
+};
+function createEventSubscriber(channel) {
+  return (callback) => {
+    const handler = (_, data) => callback(data);
+    ipcRenderer.on(channel, handler);
+    return () => ipcRenderer.removeListener(channel, handler);
+  };
+}
+const markuprApi = {
+  // ===========================================================================
+  // Session API
+  // ===========================================================================
+  session: {
+    /**
+     * Start a recording session
+     * @param sourceId - ID of the capture source (screen or window)
+     */
+    start: (sourceId, sourceName) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SESSION_START, sourceId, sourceName);
+    },
+    /**
+     * Stop the current recording session
+     */
+    stop: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SESSION_STOP);
+    },
+    /**
+     * Pause the current recording session
+     */
+    pause: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SESSION_PAUSE);
+    },
+    /**
+     * Resume a paused recording session
+     */
+    resume: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SESSION_RESUME);
+    },
+    /**
+     * Cancel the current session without saving
+     */
+    cancel: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SESSION_CANCEL);
+    },
+    /**
+     * Get current session status
+     */
+    getStatus: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_STATUS);
+    },
+    /**
+     * Get current session data
+     */
+    getCurrent: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_CURRENT);
+    },
+    /**
+     * Subscribe to session state changes
+     */
+    onStateChange: createEventSubscriber(IPC_CHANNELS.SESSION_STATE_CHANGED),
+    /**
+     * Subscribe to session status updates (periodic updates during recording)
+     */
+    onStatusUpdate: createEventSubscriber(IPC_CHANNELS.SESSION_STATUS),
+    /**
+     * Subscribe to session completion
+     */
+    onComplete: createEventSubscriber(IPC_CHANNELS.SESSION_COMPLETE),
+    /**
+     * Subscribe to new feedback items
+     */
+    onFeedbackItem: createEventSubscriber(IPC_CHANNELS.SESSION_FEEDBACK_ITEM),
+    /**
+     * Subscribe to voice activity changes
+     */
+    onVoiceActivity: createEventSubscriber(IPC_CHANNELS.SESSION_VOICE_ACTIVITY),
+    /**
+     * Subscribe to session errors
+     */
+    onError: createEventSubscriber(IPC_CHANNELS.SESSION_ERROR)
+  },
+  // ===========================================================================
+  // Capture API
+  // ===========================================================================
+  capture: {
+    /**
+     * Get available capture sources (screens and windows)
+     */
+    getSources: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CAPTURE_GET_SOURCES);
+    },
+    /**
+     * Trigger a manual screenshot during recording
+     */
+    manualScreenshot: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CAPTURE_MANUAL_SCREENSHOT);
+    },
+    /**
+     * Subscribe to screenshot captured events
+     */
+    onScreenshot: createEventSubscriber(IPC_CHANNELS.SCREENSHOT_CAPTURED),
+    /**
+     * Subscribe to manual screenshot trigger events (from hotkey)
+     */
+    onManualTrigger: createEventSubscriber(IPC_CHANNELS.MANUAL_SCREENSHOT)
+  },
+  // ===========================================================================
+  // Audio API
+  // ===========================================================================
+  audio: {
+    /**
+     * Get available audio input devices
+     * Note: Device enumeration happens in renderer via Web Audio API
+     */
+    getDevices: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.AUDIO_GET_DEVICES);
+    },
+    /**
+     * Set the preferred audio input device
+     */
+    setDevice: (deviceId) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.AUDIO_SET_DEVICE, deviceId);
+    },
+    /**
+     * Subscribe to audio level updates (for visualization)
+     */
+    onLevel: createEventSubscriber(IPC_CHANNELS.AUDIO_LEVEL),
+    /**
+     * Subscribe to voice activity detection updates
+     */
+    onVoiceActivity: createEventSubscriber(IPC_CHANNELS.AUDIO_VOICE_ACTIVITY),
+    // -------------------------------------------------------------------------
+    // Audio Capture Bridge (Renderer -> Main communication)
+    // These are used by the AudioCaptureRenderer to communicate with AudioCapture in main
+    // -------------------------------------------------------------------------
+    /**
+     * Respond to device enumeration request from main
+     */
+    onRequestDevices: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.AUDIO_REQUEST_DEVICES, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.AUDIO_REQUEST_DEVICES, handler);
+    },
+    /**
+     * Send device list back to main
+     */
+    sendDevices: (devices) => {
+      ipcRenderer.send(IPC_CHANNELS.AUDIO_DEVICES_RESPONSE, devices);
+    },
+    /**
+     * Handle start capture command from main
+     */
+    onStartCapture: (callback) => {
+      const handler = (_, config) => callback(config);
+      ipcRenderer.on(IPC_CHANNELS.AUDIO_START_CAPTURE, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.AUDIO_START_CAPTURE, handler);
+    },
+    /**
+     * Handle stop capture command from main
+     */
+    onStopCapture: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.AUDIO_STOP_CAPTURE, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.AUDIO_STOP_CAPTURE, handler);
+    },
+    /**
+     * Handle device change command from main
+     */
+    onSetDevice: (callback) => {
+      const handler = (_, deviceId) => callback(deviceId);
+      ipcRenderer.on(IPC_CHANNELS.AUDIO_SET_DEVICE, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.AUDIO_SET_DEVICE, handler);
+    },
+    /**
+     * Send audio chunk to main for transcription
+     */
+    sendAudioChunk: (data) => {
+      ipcRenderer.send(IPC_CHANNELS.AUDIO_CHUNK, data);
+    },
+    /**
+     * Notify main that capture started
+     */
+    notifyCaptureStarted: () => {
+      ipcRenderer.send(IPC_CHANNELS.AUDIO_CAPTURE_STARTED);
+    },
+    /**
+     * Notify main that capture stopped
+     */
+    notifyCaptureStopped: () => {
+      ipcRenderer.send(IPC_CHANNELS.AUDIO_CAPTURE_STOPPED);
+    },
+    /**
+     * Send capture error to main
+     */
+    sendCaptureError: (error) => {
+      ipcRenderer.send(IPC_CHANNELS.AUDIO_CAPTURE_ERROR, error);
+    }
+  },
+  // ===========================================================================
+  // Screen Recording API
+  // ===========================================================================
+  screenRecording: {
+    /**
+     * Start persisted screen recording for a session
+     */
+    start: (sessionId, mimeType, startTime) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SCREEN_RECORDING_START, sessionId, mimeType, startTime);
+    },
+    /**
+     * Append a video chunk to the active recording file
+     */
+    appendChunk: (sessionId, chunk) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SCREEN_RECORDING_CHUNK, sessionId, chunk);
+    },
+    /**
+     * Finalize persisted recording for a session
+     */
+    stop: (sessionId) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SCREEN_RECORDING_STOP, sessionId);
+    }
+  },
+  // ===========================================================================
+  // Transcription API
+  // ===========================================================================
+  transcript: {
+    /**
+     * Subscribe to transcription chunks (interim and final)
+     */
+    onChunk: createEventSubscriber(IPC_CHANNELS.TRANSCRIPTION_UPDATE),
+    /**
+     * Subscribe to final transcription results
+     */
+    onFinal: createEventSubscriber(IPC_CHANNELS.TRANSCRIPTION_FINAL)
+  },
+  // ===========================================================================
+  // Processing Pipeline API (Main -> Renderer events)
+  // ===========================================================================
+  processing: {
+    /**
+     * Subscribe to post-process pipeline progress updates
+     */
+    onProgress: createEventSubscriber(IPC_CHANNELS.PROCESSING_PROGRESS),
+    /**
+     * Subscribe to post-process pipeline completion
+     */
+    onComplete: createEventSubscriber(IPC_CHANNELS.PROCESSING_COMPLETE)
+  },
+  // ===========================================================================
+  // Transcription Control API
+  // ===========================================================================
+  transcription: {
+    /**
+     * Get runtime availability for all transcription tiers.
+     */
+    getTierStatuses: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.TRANSCRIPTION_GET_TIER_STATUSES);
+    },
+    /**
+     * Get current preferred/active transcription tier.
+     */
+    getCurrentTier: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.TRANSCRIPTION_GET_CURRENT_TIER);
+    },
+    /**
+     * Set preferred transcription tier.
+     */
+    setTier: (tier) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.TRANSCRIPTION_SET_TIER, tier);
+    },
+    /**
+     * Download a specific Whisper model via transcription controls.
+     */
+    downloadModel: (model) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WHISPER_DOWNLOAD_MODEL, model);
+    },
+    /**
+     * Cancel Whisper model download via transcription controls.
+     */
+    cancelDownload: (model) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WHISPER_CANCEL_DOWNLOAD, model);
+    },
+    /**
+     * Subscribe to Whisper model progress updates.
+     */
+    onModelProgress: createEventSubscriber(
+      IPC_CHANNELS.WHISPER_DOWNLOAD_PROGRESS
+    )
+  },
+  // ===========================================================================
+  // Settings API
+  // ===========================================================================
+  settings: {
+    /**
+     * Get a specific setting
+     */
+    get: (key) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_GET, key);
+    },
+    /**
+     * Get all settings
+     */
+    getAll: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_GET_ALL);
+    },
+    /**
+     * Set a specific setting
+     */
+    set: (key, value) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_SET, key, value);
+    },
+    /**
+     * Get an API key from secure storage
+     */
+    getApiKey: (service) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_GET_API_KEY, service);
+    },
+    /**
+     * Set an API key in secure storage
+     */
+    setApiKey: (service, key) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_SET_API_KEY, service, key);
+    },
+    /**
+     * Delete an API key from secure storage
+     */
+    deleteApiKey: (service) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_DELETE_API_KEY, service);
+    },
+    /**
+     * Check if an API key exists in secure storage
+     */
+    hasApiKey: (service) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_HAS_API_KEY, service);
+    },
+    /**
+     * Validate an API key by performing a provider request from main process.
+     */
+    testApiKey: (service, key) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_TEST_API_KEY, service, key);
+    },
+    /**
+     * Open native directory picker for output path selection
+     */
+    selectDirectory: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_SELECT_DIRECTORY);
+    },
+    /**
+     * Clear app data and reset settings
+     */
+    clearAllData: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_CLEAR_ALL_DATA);
+    },
+    /**
+     * Export settings to a JSON file
+     */
+    export: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_EXPORT);
+    },
+    /**
+     * Import settings from a JSON file
+     */
+    import: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_IMPORT);
+    }
+  },
+  // ===========================================================================
+  // Hotkey API
+  // ===========================================================================
+  hotkeys: {
+    /**
+     * Get current hotkey configuration
+     */
+    getConfig: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.HOTKEY_CONFIG);
+    },
+    /**
+     * Update hotkey configuration
+     */
+    updateConfig: (config) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.HOTKEY_UPDATE, config);
+    },
+    /**
+     * Subscribe to hotkey triggered events
+     */
+    onTriggered: createEventSubscriber(
+      IPC_CHANNELS.HOTKEY_TRIGGERED
+    )
+  },
+  // ===========================================================================
+  // Permissions API
+  // ===========================================================================
+  permissions: {
+    /**
+     * Check if a permission is granted
+     */
+    check: (type) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.PERMISSIONS_CHECK, type);
+    },
+    /**
+     * Request a permission
+     */
+    request: (type) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.PERMISSIONS_REQUEST, type);
+    },
+    /**
+     * Get all permission statuses
+     */
+    getAll: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.PERMISSIONS_GET_ALL);
+    }
+  },
+  // ===========================================================================
+  // Output API
+  // ===========================================================================
+  output: {
+    /**
+     * Save the current session to disk
+     */
+    save: (session) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_SAVE, session);
+    },
+    /**
+     * Copy session summary to clipboard
+     */
+    copyClipboard: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_COPY_CLIPBOARD);
+    },
+    /**
+     * Open the session output folder in file explorer
+     */
+    openFolder: (sessionDir) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_OPEN_FOLDER, sessionDir);
+    },
+    /**
+     * Subscribe to output ready events
+     */
+    onReady: createEventSubscriber(
+      IPC_CHANNELS.OUTPUT_READY
+    ),
+    /**
+     * Subscribe to output error events
+     */
+    onError: createEventSubscriber(IPC_CHANNELS.OUTPUT_ERROR),
+    // -------------------------------------------------------------------------
+    // Session History Browser API
+    // -------------------------------------------------------------------------
+    /**
+     * List all saved sessions
+     */
+    listSessions: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_LIST_SESSIONS);
+    },
+    /**
+     * Get metadata for a specific session
+     */
+    getSessionMetadata: (sessionId) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_GET_SESSION_METADATA, sessionId);
+    },
+    /**
+     * Delete a single session
+     */
+    deleteSession: (sessionId) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_DELETE_SESSION, sessionId);
+    },
+    /**
+     * Delete multiple sessions
+     */
+    deleteSessions: (sessionIds) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_DELETE_SESSIONS, sessionIds);
+    },
+    /**
+     * Export a single session
+     */
+    exportSession: (sessionId, format = "markdown") => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_EXPORT_SESSION, sessionId, format);
+    },
+    /**
+     * Export multiple sessions
+     */
+    exportSessions: (sessionIds, format = "markdown") => {
+      return ipcRenderer.invoke(IPC_CHANNELS.OUTPUT_EXPORT_SESSIONS, sessionIds, format);
+    }
+  },
+  // ===========================================================================
+  // Crash Recovery API
+  // ===========================================================================
+  crashRecovery: {
+    /**
+     * Check for incomplete sessions from crashes
+     */
+    check: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CRASH_RECOVERY_CHECK);
+    },
+    /**
+     * Recover an incomplete session
+     */
+    recover: (sessionId) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CRASH_RECOVERY_RECOVER, sessionId);
+    },
+    /**
+     * Discard an incomplete session
+     */
+    discard: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CRASH_RECOVERY_DISCARD);
+    },
+    /**
+     * Get recent crash logs for debugging
+     */
+    getLogs: (limit) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CRASH_RECOVERY_GET_LOGS, limit);
+    },
+    /**
+     * Clear crash logs
+     */
+    clearLogs: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CRASH_RECOVERY_CLEAR_LOGS);
+    },
+    /**
+     * Update crash recovery settings
+     */
+    updateSettings: (settings) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.CRASH_RECOVERY_UPDATE_SETTINGS, settings);
+    },
+    /**
+     * Subscribe to incomplete session found events (on startup)
+     */
+    onIncompleteFound: createEventSubscriber(IPC_CHANNELS.CRASH_RECOVERY_FOUND)
+  },
+  // ===========================================================================
+  // Updates API
+  // ===========================================================================
+  updates: {
+    /**
+     * Check for available updates
+     */
+    check: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.UPDATE_CHECK);
+    },
+    /**
+     * Download the available update
+     */
+    download: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.UPDATE_DOWNLOAD);
+    },
+    /**
+     * Install the downloaded update (quits and restarts app)
+     */
+    install: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.UPDATE_INSTALL);
+    },
+    /**
+     * Subscribe to update status changes
+     */
+    onStatus: (callback) => {
+      const handler = (_, status) => callback(status);
+      ipcRenderer.on(IPC_CHANNELS.UPDATE_STATUS, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.UPDATE_STATUS, handler);
+    }
+  },
+  // ===========================================================================
+  // Whisper Model API
+  // ===========================================================================
+  whisper: {
+    /**
+     * Check if any Whisper model is downloaded and get recommended model
+     */
+    checkModel: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WHISPER_CHECK_MODEL);
+    },
+    /**
+     * Check if we have any tier that can actually transcribe
+     * (OpenAI key or Whisper with model)
+     */
+    hasTranscriptionCapability: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WHISPER_HAS_TRANSCRIPTION_CAPABILITY);
+    },
+    /**
+     * Get available models with their info
+     */
+    getAvailableModels: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WHISPER_GET_AVAILABLE_MODELS);
+    },
+    /**
+     * Download a specific Whisper model
+     * @param model - Model name: 'tiny', 'base', 'small', 'medium', or 'large'
+     */
+    downloadModel: (model) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WHISPER_DOWNLOAD_MODEL, model);
+    },
+    /**
+     * Cancel an active download
+     * @param model - Model name to cancel
+     */
+    cancelDownload: (model) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WHISPER_CANCEL_DOWNLOAD, model);
+    },
+    /**
+     * Subscribe to download progress events
+     */
+    onDownloadProgress: createEventSubscriber(
+      IPC_CHANNELS.WHISPER_DOWNLOAD_PROGRESS
+    ),
+    /**
+     * Subscribe to download complete events
+     */
+    onDownloadComplete: createEventSubscriber(
+      IPC_CHANNELS.WHISPER_DOWNLOAD_COMPLETE
+    ),
+    /**
+     * Subscribe to download error events
+     */
+    onDownloadError: createEventSubscriber(
+      IPC_CHANNELS.WHISPER_DOWNLOAD_ERROR
+    )
+  },
+  // ===========================================================================
+  // App Version
+  // ===========================================================================
+  version: () => {
+    return ipcRenderer.invoke(IPC_CHANNELS.APP_VERSION);
+  },
+  // ===========================================================================
+  // Legacy API (for backwards compatibility)
+  // ===========================================================================
+  startSession: () => {
+    return ipcRenderer.invoke(IPC_CHANNELS.START_SESSION);
+  },
+  stopSession: () => {
+    return ipcRenderer.invoke(IPC_CHANNELS.STOP_SESSION);
+  },
+  getSettings: () => {
+    return ipcRenderer.invoke(IPC_CHANNELS.GET_SETTINGS);
+  },
+  setSettings: (settings) => {
+    return ipcRenderer.invoke(IPC_CHANNELS.SET_SETTINGS, settings);
+  },
+  copyToClipboard: (text) => {
+    return ipcRenderer.invoke(IPC_CHANNELS.COPY_TO_CLIPBOARD, text);
+  },
+  // Window controls
+  window: {
+    minimize: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WINDOW_MINIMIZE);
+    },
+    hide: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WINDOW_HIDE);
+    },
+    close: () => {
+      return ipcRenderer.invoke(IPC_CHANNELS.WINDOW_CLOSE);
+    }
+  },
+  // Popover controls
+  popover: {
+    resize: (width, height) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.POPOVER_RESIZE, width, height);
+    },
+    resizeToState: (state) => {
+      return ipcRenderer.invoke(IPC_CHANNELS.POPOVER_RESIZE_TO_STATE, state);
+    }
+  },
+  // ===========================================================================
+  // Navigation API (Main -> Renderer navigation events)
+  // ===========================================================================
+  navigation: {
+    onShowSettings: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.SHOW_SETTINGS, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.SHOW_SETTINGS, handler);
+    },
+    onShowHistory: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.SHOW_HISTORY, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.SHOW_HISTORY, handler);
+    },
+    onShowShortcuts: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.SHOW_SHORTCUTS, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.SHOW_SHORTCUTS, handler);
+    },
+    onShowOnboarding: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.SHOW_ONBOARDING, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.SHOW_ONBOARDING, handler);
+    },
+    onShowExport: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.SHOW_EXPORT, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.SHOW_EXPORT, handler);
+    },
+    onShowWindowSelector: (callback) => {
+      const handler = () => callback();
+      ipcRenderer.on(IPC_CHANNELS.SHOW_WINDOW_SELECTOR, handler);
+      return () => ipcRenderer.removeListener(IPC_CHANNELS.SHOW_WINDOW_SELECTOR, handler);
+    }
+  },
+  onSessionStatus: (callback) => {
+    const handler = (_, data) => callback(data);
+    ipcRenderer.on(IPC_CHANNELS.SESSION_STATUS, handler);
+    return () => ipcRenderer.removeListener(IPC_CHANNELS.SESSION_STATUS, handler);
+  },
+  onTranscriptionUpdate: (callback) => {
+    const handler = (_, data) => callback(data);
+    ipcRenderer.on(IPC_CHANNELS.TRANSCRIPTION_UPDATE, handler);
+    return () => ipcRenderer.removeListener(IPC_CHANNELS.TRANSCRIPTION_UPDATE, handler);
+  },
+  onScreenshotCaptured: (callback) => {
+    const handler = (_, data) => callback(data);
+    ipcRenderer.on(IPC_CHANNELS.SCREENSHOT_CAPTURED, handler);
+    return () => ipcRenderer.removeListener(IPC_CHANNELS.SCREENSHOT_CAPTURED, handler);
+  },
+  onOutputReady: (callback) => {
+    const handler = (_, data) => callback(data);
+    ipcRenderer.on(IPC_CHANNELS.OUTPUT_READY, handler);
+    return () => ipcRenderer.removeListener(IPC_CHANNELS.OUTPUT_READY, handler);
+  },
+  onOutputError: (callback) => {
+    const handler = (_, error) => callback(error);
+    ipcRenderer.on(IPC_CHANNELS.OUTPUT_ERROR, handler);
+    return () => ipcRenderer.removeListener(IPC_CHANNELS.OUTPUT_ERROR, handler);
+  }
+};
+contextBridge.exposeInMainWorld("markupr", markuprApi);