Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

27.8 KB
Raw Blame
import { contextBridge, ipcRenderer, sharedTexture, webUtils } from "electron";
import type { NativeLinuxRecordingRequest } from "../src/lib/nativeLinuxRecording";
import type { NativeMacRecordingRequest } from "../src/lib/nativeMacRecording";
import type { NativeWindowsRecordingRequest } from "../src/lib/nativeWindowsRecording";
import type { RecordingSession, StoreRecordedSessionInput } from "../src/lib/recordingSession";
import type { ShortcutBinding } from "../src/lib/shortcuts";
import type {
	AiEditionChatEvent,
	AiEditionMcpHostRequest,
	AiEditionMcpHostResponse,
	CompositorSharedFrameMeta,
} from "../src/native/contracts";
import {
	AI_EDITION_MCP_HOST_CHANNEL,
	AI_EDITION_MCP_REQUEST_CHANNEL,
	AI_EDITION_MCP_RESPONSE_CHANNEL,
	AI_EDITION_OPEN_PROJECT_CHANNEL,
	NATIVE_BRIDGE_CHANNEL,
	type NativeBridgeRequest,
} from "../src/native/contracts";
import type { UpdateBadge } from "./background-update";
import type { RecordingPrefs } from "./ipc/handlers";
import type {
	SttStatusEvent,
	SttTranscribeRequest,
	SttTranscribeResponse,
} from "./stt/transcriptionContract";

// Asset base URL is passed from the main process via webPreferences.additionalArguments
// (see windows.ts). Sandboxed preloads cannot import node:path / node:url, so we
// can't compute it here.
const ASSET_BASE_URL_ARG_PREFIX = "--asset-base-url=";
const assetBaseUrlArg = process.argv.find((arg) => arg.startsWith(ASSET_BASE_URL_ARG_PREFIX));
const assetBaseUrl = assetBaseUrlArg ? assetBaseUrlArg.slice(ASSET_BASE_URL_ARG_PREFIX.length) : "";

// Renderer side: process.platform is the same Node global as in the main process,
// so a synchronous read here saves the renderer's every-call IPC round-trip.
const PLATFORM = process.platform;

// Preview frames the main process hands over as shared GPU textures (see
// `compositorViewService`). Electron gives up on a send after 1 s without a receiver, so it is
// registered here, at load, and forwards to whichever listener the page has set.
type CompositorFrameListener = (frame: VideoFrame, meta: CompositorSharedFrameMeta) => void;
let compositorFrameListener: CompositorFrameListener | null = null;
sharedTexture?.setSharedTextureReceiver(async ({ importedSharedTexture }, meta) => {
	const frame = importedSharedTexture.getVideoFrame();
	try {
		compositorFrameListener?.(frame, meta as CompositorSharedFrameMeta);
	} finally {
		// The page drew from its own copy (contextBridge clones the frame) and closed it. Closing
		// ours and releasing the import is what lets the native ring write the slot again.
		frame.close();
		importedSharedTexture.release();
	}
});

contextBridge.exposeInMainWorld("electronAPI", {
	assetBaseUrl,

	// The renderer's navigator.clipboard.writeText is denied by Electron's
	// permission gate (clipboard-sanitized-write), which left chat's Copy
	// message permanently on its error toast (issue #738). Main's clipboard
	// module has no such gate, so the write crosses here.
	copyToClipboard: (text: string) =>
		ipcRenderer.invoke("clipboard:write-text", text) as Promise<void>,

	// --- Native export encoder -------------------------------------------------
	// The renderer composites and extracts frames but cannot spawn ffmpeg (it is
	// sandboxed, deliberately), so frames cross to main and it feeds ffmpeg's
	// stdin. Frames go one-way via send(); flow control is the caller's credit
	// window, acked on exportOnFrameAck.
	exportCapabilities: () =>
		ipcRenderer.invoke("export:capabilities") as Promise<{ encoder: string }>,
	exportStart: (req: unknown) =>
		ipcRenderer.invoke("export:start", req) as Promise<{
			sessionId: string;
			encoder: string;
			outputPath: string;
		}>,
	exportWriteFrame: (sessionId: string, frame: ArrayBuffer) => {
		// send() structured-clones, i.e. copies the frame. That is not an oversight
		// and it is not fixable here: Electron's transfer list takes MessagePort[]
		// only, and transferring an ArrayBuffer renderer->main silently drops the
		// whole message (electron#34905 - it works renderer->renderer, not to main).
		// The copy is what caps the crossing at ~390 MB/s, which is why the export
		// ships NV12 (3.0 MB/frame) rather than BGRA (7.9 MB).
		ipcRenderer.send("export:frame", sessionId, frame);
	},
	exportOnFrameAck: (cb: (sessionId: string, error: string | null) => void) => {
		const handler = (_e: unknown, sessionId: string, error: string | null) => cb(sessionId, error);
		ipcRenderer.on("export:frame-ack", handler);
		return () => ipcRenderer.off("export:frame-ack", handler);
	},
	exportFinish: (sessionId: string) =>
		ipcRenderer.invoke("export:finish", sessionId) as Promise<{ outputPath: string }>,
	exportCancel: (sessionId: string) =>
		ipcRenderer.invoke("export:cancel", sessionId) as Promise<void>,
	/** Export bench only (--bench=): tells main the run is over so it can quit. */
	benchFinished: () => ipcRenderer.invoke("bench:finished") as Promise<void>,
	/** Native (D3D) export progress — frames encoded so far, pushed at ~10 Hz max while
	 *  `compositor.export`/`compositor.exportMulti` runs. Distinct from `exportOnFrameAck`
	 *  above, which is the OLD web/CPU pipeline's per-frame ack, not a progress signal. */
	onNativeExportProgress: (cb: (frames: number, exportId?: string) => void) => {
		const handler = (_e: unknown, frames: number, exportId?: string) => cb(frames, exportId);
		ipcRenderer.on("export:native-progress", handler);
		return () => ipcRenderer.off("export:native-progress", handler);
	},
	onCompositorFrame: (listener: CompositorFrameListener) => {
		compositorFrameListener = listener;
		return () => {
			if (compositorFrameListener === listener) {
				compositorFrameListener = null;
			}
		};
	},
	invokeNativeBridge: <TData>(request: NativeBridgeRequest) => {
		return ipcRenderer.invoke(NATIVE_BRIDGE_CHANNEL, request) as Promise<TData>;
	},
	hudOverlayHide: () => {
		ipcRenderer.send("hud-overlay-hide");
	},
	hudOverlayClose: () => {
		ipcRenderer.send("hud-overlay-close");
	},
	setHudOverlayIgnoreMouseEvents: (ignore: boolean) => {
		ipcRenderer.send("hud-overlay-ignore-mouse-events", ignore);
	},
	onHudOverlayCursor: (callback: (x: number, y: number) => void) => {
		const listener = (_e: Electron.IpcRendererEvent, x: number, y: number) => callback(x, y);
		ipcRenderer.on("hud-overlay-cursor", listener);
		return () => ipcRenderer.removeListener("hud-overlay-cursor", listener);
	},
	beginHudOverlayDrag: () => {
		ipcRenderer.send("hud-overlay-drag-start");
	},
	dragHudOverlayTo: (deltaX: number, deltaY: number) => {
		ipcRenderer.send("hud-overlay-drag-to", deltaX, deltaY);
	},
	endHudOverlayDrag: () => {
		ipcRenderer.send("hud-overlay-drag-end");
	},
	setHudOverlaySize: (
		width: number,
		height: number,
		content: { x: number; y: number; width: number; height: number },
	) => {
		ipcRenderer.send("hud-overlay-set-size", width, height, content);
	},
	setHudOverlayContent: (content: { x: number; y: number; width: number; height: number }) => {
		ipcRenderer.send("hud-overlay-content", content);
	},
	getSources: async (opts: Electron.SourcesOptions) => {
		return await ipcRenderer.invoke("get-sources", opts);
	},
	switchToEditor: () => {
		return ipcRenderer.invoke("switch-to-editor");
	},
	switchToHud: () => {
		return ipcRenderer.invoke("switch-to-hud");
	},
	startNewRecording: () => {
		return ipcRenderer.invoke("start-new-recording");
	},
	openSourceSelector: () => {
		return ipcRenderer.invoke("open-source-selector");
	},
	usesSystemSourcePicker: (): Promise<boolean> => {
		return ipcRenderer.invoke("uses-system-source-picker");
	},
	getLastPickedSource: (): Promise<string | null> => {
		return ipcRenderer.invoke("get-last-picked-source");
	},
	openNotes: () => {
		return ipcRenderer.invoke("open-notes");
	},
	selectSource: (source: ProcessedDesktopSource, options?: { persist?: boolean }) => {
		return ipcRenderer.invoke("select-source", source, options);
	},
	getSelectedSource: () => {
		return ipcRenderer.invoke("get-selected-source");
	},
	getRecordingPrefs: () => {
		return ipcRenderer.invoke("get-recording-prefs");
	},
	setRecordingPrefs: (prefs: Partial<RecordingPrefs>) => {
		return ipcRenderer.invoke("set-recording-prefs", prefs);
	},
	onRecordingPrefsChanged: (callback: (prefs: RecordingPrefs) => void) => {
		const listener = (_event: unknown, prefs: RecordingPrefs) => callback(prefs);
		ipcRenderer.on("recording-prefs-changed", listener);
		return () => ipcRenderer.removeListener("recording-prefs-changed", listener);
	},
	onSelectedSourceChanged: (callback: (source: ProcessedDesktopSource | null) => void) => {
		const listener = (_event: unknown, source: ProcessedDesktopSource | null) => callback(source);
		ipcRenderer.on("selected-source-changed", listener);
		return () => ipcRenderer.removeListener("selected-source-changed", listener);
	},
	onSourceSelectorClosed: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("source-selector-closed", listener);
		return () => ipcRenderer.removeListener("source-selector-closed", listener);
	},
	onAutoStartRecording: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("hud-auto-start-recording", listener);
		return () => ipcRenderer.removeListener("hud-auto-start-recording", listener);
	},
	requestCameraAccess: () => {
		return ipcRenderer.invoke("request-camera-access");
	},
	permissions: {
		get: () => ipcRenderer.invoke("permissions:get"),
		request: (kind: string) => ipcRenderer.invoke("permissions:request", kind),
		openSettings: (kind: string) => ipcRenderer.invoke("permissions:open-settings", kind),
		relaunch: () => ipcRenderer.invoke("permissions:relaunch"),
		close: () => ipcRenderer.invoke("permissions:close"),
	},
	requestNativeMacCursorAccess: () => {
		return ipcRenderer.invoke("request-native-mac-cursor-access");
	},
	storeRecordedVideo: (videoData: ArrayBuffer, fileName: string) => {
		return ipcRenderer.invoke("store-recorded-video", videoData, fileName);
	},
	storeRecordedSession: (payload: StoreRecordedSessionInput) => {
		return ipcRenderer.invoke("store-recorded-session", payload);
	},
	openRecordingStream: (fileName: string) => {
		return ipcRenderer.invoke("open-recording-stream", fileName);
	},
	appendRecordingChunk: (fileName: string, chunk: ArrayBuffer) => {
		return ipcRenderer.invoke("append-recording-chunk", fileName, chunk);
	},
	closeRecordingStream: (fileName: string) => {
		return ipcRenderer.invoke("close-recording-stream", fileName);
	},

	getRecordedVideoPath: () => {
		return ipcRenderer.invoke("get-recorded-video-path");
	},
	setRecordingState: (
		recording: boolean,
		recordingId?: number,
		cursorCaptureMode?: import("../src/lib/recordingSession").CursorCaptureMode,
		reserveOnly?: boolean,
	) => {
		return ipcRenderer.invoke(
			"set-recording-state",
			recording,
			recordingId,
			cursorCaptureMode,
			reserveOnly,
		);
	},
	isNativeWindowsCaptureAvailable: () => {
		return ipcRenderer.invoke("is-native-windows-capture-available");
	},
	isNativeMacCaptureAvailable: () => {
		return ipcRenderer.invoke("is-native-mac-capture-available");
	},
	isNativeLinuxCaptureAvailable: () => {
		return ipcRenderer.invoke("is-native-linux-capture-available");
	},
	prepareNativeLinuxRecording: (request: NativeLinuxRecordingRequest) => {
		return ipcRenderer.invoke("prepare-native-linux-recording", request);
	},
	cancelNativeLinuxPrepare: () => {
		return ipcRenderer.invoke("cancel-native-linux-prepare");
	},
	startNativeLinuxRecording: (request: NativeLinuxRecordingRequest) => {
		return ipcRenderer.invoke("start-native-linux-recording", request);
	},
	pauseNativeLinuxRecording: () => {
		return ipcRenderer.invoke("pause-native-linux-recording");
	},
	resumeNativeLinuxRecording: () => {
		return ipcRenderer.invoke("resume-native-linux-recording");
	},
	stopNativeLinuxRecording: (discard?: boolean) => {
		return ipcRenderer.invoke("stop-native-linux-recording", discard);
	},
	attachNativeLinuxWebcamRecording: (payload: {
		screenVideoPath: string;
		recordingId: number;
		webcam: { fileName: string; videoData: ArrayBuffer };
		cursorCaptureMode?: import("../src/lib/recordingSession").CursorCaptureMode;
		durationMs?: number;
		webcamOffsetMs?: number;
	}) => {
		return ipcRenderer.invoke("attach-native-linux-webcam-recording", payload);
	},
	startNativeWindowsRecording: (request: NativeWindowsRecordingRequest) => {
		return ipcRenderer.invoke("start-native-windows-recording", request);
	},
	stopNativeWindowsRecording: (discard?: boolean) => {
		return ipcRenderer.invoke("stop-native-windows-recording", discard);
	},
	pauseNativeWindowsRecording: () => {
		return ipcRenderer.invoke("pause-native-windows-recording");
	},
	resumeNativeWindowsRecording: () => {
		return ipcRenderer.invoke("resume-native-windows-recording");
	},
	startNativeMacRecording: (request: NativeMacRecordingRequest) => {
		return ipcRenderer.invoke("start-native-mac-recording", request);
	},
	onNativeMacSystemAudioUnavailable: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("native-mac-system-audio-unavailable", listener);
		return () => ipcRenderer.removeListener("native-mac-system-audio-unavailable", listener);
	},
	pauseNativeMacRecording: () => {
		return ipcRenderer.invoke("pause-native-mac-recording");
	},
	resumeNativeMacRecording: () => {
		return ipcRenderer.invoke("resume-native-mac-recording");
	},
	stopNativeMacRecording: (discard?: boolean) => {
		return ipcRenderer.invoke("stop-native-mac-recording", discard);
	},
	attachNativeMacWebcamRecording: (payload: {
		screenVideoPath: string;
		recordingId: number;
		webcam: { fileName: string; videoData: ArrayBuffer };
		cursorCaptureMode?: import("../src/lib/recordingSession").CursorCaptureMode;
		durationMs?: number;
		webcamOffsetMs?: number;
	}) => {
		return ipcRenderer.invoke("attach-native-mac-webcam-recording", payload);
	},
	getCursorTelemetry: (videoPath?: string) => {
		return ipcRenderer.invoke("get-cursor-telemetry", videoPath);
	},
	discardCursorTelemetry: (recordingId: number) => {
		return ipcRenderer.invoke("discard-cursor-telemetry", recordingId);
	},
	onStopRecordingFromTray: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("stop-recording-from-tray", listener);
		return () => ipcRenderer.removeListener("stop-recording-from-tray", listener);
	},
	openExternalUrl: (url: string) => {
		return ipcRenderer.invoke("open-external-url", url);
	},
	// The star ask. The renderer reports that an export finished and is told yes or no; the
	// counters, the take flag and the install channel stay in the main process.
	openRepoPage: () => {
		return ipcRenderer.invoke("star-prompt:open-repo");
	},
	starPromptExportFinished: () => {
		return ipcRenderer.invoke("star-prompt:export-finished");
	},
	dismissStarPrompt: () => {
		return ipcRenderer.invoke("star-prompt:dismiss");
	},
	// No URL argument on purpose: main builds the `ms-windows-store:` link from a constant.
	openStoreReview: () => {
		return ipcRenderer.invoke("star-prompt:open-store-review");
	},
	pickExportSavePath: (fileName: string, exportFolder?: string) => {
		return ipcRenderer.invoke("pick-export-save-path", fileName, exportFolder);
	},
	writeExportToPath: (videoData: ArrayBuffer, filePath: string) => {
		return ipcRenderer.invoke("write-export-to-path", videoData, filePath);
	},
	openVideoFilePicker: () => {
		return ipcRenderer.invoke("open-video-file-picker");
	},
	openAudioFilePicker: () => {
		return ipcRenderer.invoke("open-audio-file-picker");
	},
	saveRecordedVoiceover: (data: ArrayBuffer) => {
		return ipcRenderer.invoke("save-recorded-voiceover", data);
	},
	stageClickSoundHit: (name: string, data: ArrayBuffer) => {
		return ipcRenderer.invoke("stage-click-sound-hit", name, data);
	},
	setCurrentVideoPath: (path: string) => {
		return ipcRenderer.invoke("set-current-video-path", path);
	},
	setCurrentRecordingSession: (session: RecordingSession | null) => {
		return ipcRenderer.invoke("set-current-recording-session", session);
	},
	getCurrentVideoPath: () => {
		return ipcRenderer.invoke("get-current-video-path");
	},
	getCurrentRecordingSession: () => {
		return ipcRenderer.invoke("get-current-recording-session");
	},
	findRecordingCamera: (videoPath: string) => {
		return ipcRenderer.invoke("find-recording-camera", videoPath);
	},
	readBinaryFile: (filePath: string) => {
		return ipcRenderer.invoke("read-binary-file", filePath);
	},
	getReadableFileInfo: (filePath: string) => {
		return ipcRenderer.invoke("get-readable-file-info", filePath);
	},
	/** Native waveform peaks, disk-cached. See electron/media/audioPeaks.ts. */
	getAudioPeaks: (filePath: string, durationSec: number) => {
		return ipcRenderer.invoke("get-audio-peaks", filePath, durationSec);
	},
	readFileChunk: (filePath: string, offset: number, length: number) => {
		return ipcRenderer.invoke("read-file-chunk", filePath, offset, length);
	},
	preparePreviewAudioTrack: (filePath: string) => {
		return ipcRenderer.invoke("prepare-preview-audio-track", filePath);
	},
	/** Loudness-normalisation gain the export applies to a voice file. See the handler. */
	getLoudnessGain: (filePath: string) => {
		return ipcRenderer.invoke("get-loudness-gain", filePath);
	},
	clearCurrentVideoPath: () => {
		return ipcRenderer.invoke("clear-current-video-path");
	},
	saveProjectFile: (projectData: unknown, suggestedName?: string, existingProjectPath?: string) => {
		return ipcRenderer.invoke("save-project-file", projectData, suggestedName, existingProjectPath);
	},
	loadProjectFile: (projectFolder?: string) => {
		return ipcRenderer.invoke("load-project-file", projectFolder);
	},
	loadProjectFileFromPath: (filePath: string) => {
		return ipcRenderer.invoke("load-project-file-from-path", filePath);
	},
	getPathForFile: (file: File) => {
		try {
			return webUtils.getPathForFile(file);
		} catch {
			return "";
		}
	},
	loadCurrentProjectFile: () => {
		return ipcRenderer.invoke("load-current-project-file");
	},
	onMenuNewProject: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("menu-new-project", listener);
		return () => ipcRenderer.removeListener("menu-new-project", listener);
	},
	onMenuImportVideo: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("menu-import-video", listener);
		return () => ipcRenderer.removeListener("menu-import-video", listener);
	},
	onMenuLoadProject: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("menu-load-project", listener);
		return () => ipcRenderer.removeListener("menu-load-project", listener);
	},
	onMenuSaveProject: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("menu-save-project", listener);
		return () => ipcRenderer.removeListener("menu-save-project", listener);
	},
	onMenuSaveProjectAs: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("menu-save-project-as", listener);
		return () => ipcRenderer.removeListener("menu-save-project-as", listener);
	},
	// The Edit menu's Undo/Redo. On macOS this is the ONLY way Cmd+Z reaches the
	// renderer: AppKit matches the menu's key equivalent before the key event is
	// delivered to the web contents, so the document-level keydown handler never
	// runs. See `electron/edit-menu.ts`.
	onMenuUndo: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("menu-undo", listener);
		return () => ipcRenderer.removeListener("menu-undo", listener);
	},
	onMenuRedo: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("menu-redo", listener);
		return () => ipcRenderer.removeListener("menu-redo", listener);
	},
	quitApp: () => {
		ipcRenderer.send("app-quit");
	},
	setTitleBarOverlay: (color: string, symbolColor: string) => {
		ipcRenderer.send("set-titlebar-overlay", color, symbolColor);
	},
	getPlatform: () => PLATFORM,
	/** The OS version, as the main process reads it: "14.6.1" on macOS, not the Darwin
	 *  kernel's "23.6.0" that `os.release()` gives. Part of the sandboxed preload's `process`. */
	getSystemVersion: () => process.getSystemVersion(),
	/** App identity for the HUD's settings panel: the running version, and whether this copy
	 *  may offer an update check at all — a Store/Flathub/Snap/Nix install may not, see
	 *  electron/install-channel.ts. */
	getAppInfo: () =>
		ipcRenderer.invoke("get-app-info") as Promise<{
			version: string;
			canCheckForUpdates: boolean;
		}>,
	/** Resolves once the check has a verdict. The dialogs that verdict leads to — download,
	 *  restart — are the main process's conversation, not the caller's. */
	checkForUpdates: () => ipcRenderer.invoke("check-for-updates") as Promise<void>,
	/** Opens the main process's About box (or the native panel on macOS). Resolves as soon as
	 *  the box is up, NOT when it is dismissed — there is no verdict to wait for, unlike
	 *  `checkForUpdates` above. */
	showAbout: () => ipcRenderer.invoke("show-about") as Promise<void>,
	/** The full update veto, asked fresh. `getAppInfo().canCheckForUpdates` answers only the
	 *  permanent half; this one also answers "not mid-take", so it is only correct for a caller
	 *  that asks at the moment it shows the affordance. */
	canCheckForUpdatesNow: () => ipcRenderer.invoke("can-check-for-updates-now") as Promise<boolean>,
	/** The update button's state: null hides it. Found by the main process's background check. */
	getUpdateBadge: () => ipcRenderer.invoke("get-update-badge") as Promise<UpdateBadge | null>,
	onUpdateBadgeChanged: (callback: (badge: UpdateBadge | null) => void) => {
		const listener = (_event: unknown, badge: UpdateBadge | null) => callback(badge);
		ipcRenderer.on("update-badge-changed", listener);
		return () => ipcRenderer.removeListener("update-badge-changed", listener);
	},
	/** The button's click. Resolves at once; the dialogs or the restart that follow are the main
	 *  process's. */
	applyUpdate: () => ipcRenderer.invoke("apply-update") as Promise<void>,
	revealInFolder: (filePath: string) => {
		return ipcRenderer.invoke("reveal-in-folder", filePath);
	},
	checkRecordingStorage: () => {
		return ipcRenderer.invoke("check-recording-storage") as Promise<
			{ success: true } | { success: false; error: string }
		>;
	},
	getRecordingsDir: () => {
		return ipcRenderer.invoke("get-recordings-dir") as Promise<{
			path: string;
			isDefault: boolean;
		}>;
	},
	chooseRecordingsDir: () => {
		return ipcRenderer.invoke("choose-recordings-dir") as Promise<
			{ success: true; path: string } | { success: false; canceled?: boolean; message?: string }
		>;
	},
	resetRecordingsDir: () => {
		return ipcRenderer.invoke("reset-recordings-dir") as Promise<
			{ success: true; path: string } | { success: false; message?: string }
		>;
	},
	getShortcuts: () => {
		return ipcRenderer.invoke("get-shortcuts");
	},
	saveShortcuts: (shortcuts: unknown) => {
		return ipcRenderer.invoke("save-shortcuts", shortcuts);
	},
	updateGlobalShortcut: (binding: ShortcutBinding) => {
		return ipcRenderer.invoke("update-global-shortcut", binding);
	},
	setLocale: (locale: string) => {
		return ipcRenderer.invoke("set-locale", locale);
	},
	saveDiagnostic: (payload: {
		error: string;
		stack?: string;
		projectState: unknown;
		logs: string[];
	}) => {
		return ipcRenderer.invoke("save-diagnostic", payload);
	},
	setMicrophoneExpanded: (expanded: boolean) => {
		ipcRenderer.send("hud:setMicrophoneExpanded", expanded);
	},
	setHasUnsavedChanges: (hasChanges: boolean) => {
		ipcRenderer.send("set-has-unsaved-changes", hasChanges);
	},
	showCountdownOverlay: (value: number, runId: number) => {
		return ipcRenderer.invoke("countdown-overlay-show", value, runId);
	},
	setCountdownOverlayValue: (value: number, runId: number) => {
		return ipcRenderer.invoke("countdown-overlay-set-value", value, runId);
	},
	hideCountdownOverlay: (runId: number) => {
		return ipcRenderer.invoke("countdown-overlay-hide", runId);
	},
	onCountdownOverlayValue: (callback: (value: number | null, runId: number) => void) => {
		const listener = (_event: unknown, value: number | null, runId: number) =>
			callback(value, runId);
		ipcRenderer.on("countdown-overlay-value", listener);
		return () => ipcRenderer.removeListener("countdown-overlay-value", listener);
	},
	notifyCountdownOverlayCleared: (runId: number) => {
		ipcRenderer.send("countdown-overlay-cleared", runId);
	},
	onRequestSaveBeforeClose: (callback: () => Promise<boolean> | boolean) => {
		const listener = async () => {
			try {
				const shouldClose = await callback();
				ipcRenderer.send("save-before-close-done", shouldClose);
			} catch {
				ipcRenderer.send("save-before-close-done", false);
			}
		};
		ipcRenderer.on("request-save-before-close", listener);
		return () => ipcRenderer.removeListener("request-save-before-close", listener);
	},
	onRequestCloseConfirm: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("request-close-confirm", listener);
		return () => ipcRenderer.removeListener("request-close-confirm", listener);
	},
	sendCloseConfirmResponse: (choice: "save" | "discard" | "cancel") => {
		ipcRenderer.send("close-confirm-response", choice);
	},
	// ponytail: forward renderer console output to main-process stdout so
	// recorder diagnostics land next to the main-process logs in dev output.
	// One-way fire-and-forget; we deliberately don't await the IPC.
	rendererConsole: (channel: "log" | "warn" | "error", args: unknown[]) => {
		ipcRenderer.send(`renderer-console-${channel}`, ...args);
	},
	onAiEditionChatEvent: (callback: (event: AiEditionChatEvent) => void) => {
		const listener = (_e: unknown, payload: AiEditionChatEvent) => callback(payload);
		ipcRenderer.on("ai-edition.chat-event", listener);
		return () => ipcRenderer.removeListener("ai-edition.chat-event", listener);
	},
	// The editor answers the MCP server's reads and writes of the live document.
	// Subscribing is what makes this window the one the server asks; the
	// returned unsubscribe withdraws it. See electron/mcp/editor-document-host.ts.
	onAiEditionMcpRequest: (
		callback: (request: AiEditionMcpHostRequest) => Promise<AiEditionMcpHostResponse["result"]>,
	) => {
		const listener = (_e: unknown, request: AiEditionMcpHostRequest) => {
			void callback(request).then(
				(result) =>
					ipcRenderer.send(AI_EDITION_MCP_RESPONSE_CHANNEL, {
						requestId: request.requestId,
						result,
					}),
				() =>
					ipcRenderer.send(AI_EDITION_MCP_RESPONSE_CHANNEL, {
						requestId: request.requestId,
						result: null,
					}),
			);
		};
		ipcRenderer.on(AI_EDITION_MCP_REQUEST_CHANNEL, listener);
		ipcRenderer.send(AI_EDITION_MCP_HOST_CHANNEL, true);
		return () => {
			ipcRenderer.removeListener(AI_EDITION_MCP_REQUEST_CHANNEL, listener);
			ipcRenderer.send(AI_EDITION_MCP_HOST_CHANNEL, false);
		};
	},
	// The project the editor holds, for `openscreen mcp` in another process (#1138).
	setAiEditionOpenProject: (projectId: string | null) => {
		ipcRenderer.send(AI_EDITION_OPEN_PROJECT_CHANNEL, projectId);
	},
	stt: {
		transcribe: (request: SttTranscribeRequest): Promise<SttTranscribeResponse> => {
			return ipcRenderer.invoke("stt:transcribe", request) as Promise<SttTranscribeResponse>;
		},
		/** Stop the running transcription at its next chunk boundary. */
		cancel: (): Promise<void> => ipcRenderer.invoke("stt:cancel") as Promise<void>,
		onStatus: (callback: (event: SttStatusEvent) => void) => {
			const listener = (_event: unknown, payload: SttStatusEvent) => callback(payload);
			ipcRenderer.on("stt:status", listener);
			return () => ipcRenderer.removeListener("stt:status", listener);
		},
	},
	// --- CLI mode (hidden runner windows; see electron/cli/) ---
	cliGetRequest: (): Promise<import("../src/lib/cliContracts").CliRequest> => {
		return ipcRenderer.invoke("cli-get-request");
	},
	cliProgress: (progress: import("../src/lib/cliContracts").CliProgressEvent) => {
		ipcRenderer.send("cli-progress", progress);
	},
	cliLog: (level: "info" | "error", message: string) => {
		ipcRenderer.send("cli-log", level, message);
	},
	cliDone: (result: import("../src/lib/cliContracts").CliDoneResult) => {
		return ipcRenderer.invoke("cli-done", result);
	},
	onCliStopRecording: (callback: () => void) => {
		const listener = () => callback();
		ipcRenderer.on("cli-stop-recording", listener);
		return () => ipcRenderer.removeListener("cli-stop-recording", listener);
	},
});