feat(desktop): port v0.11.4-v0.15.2 from Tauri to Electron + Discord-parity audio (v0.16.0)

Chronological port of every Tauri release commit (v0.11.4 -> v0.15.2)
into the Electron rebuild, plus Discord-style audio handling that goes
beyond the Tauri original.

Highlights:
  - All 17 Tauri release commits ported (audio fixes, custom notification
    sound, Discord-style chat UX, profile banner, changelog page,
    Discord-parity call UX, screen-share echo + re-watch UX, audio-loop
    fix).
  - Native napi-rs audio-loopback addon with WASAPI process-loopback:
      * EXCLUDE_TARGET_PROCESS_TREE for full-screen shares -> peers
        never hear themselves echoed back through the capture.
      * INCLUDE_TARGET_PROCESS_TREE for window shares -> only the
        picked window's audio is captured, not the whole OS mixer
        (Discord parity).
      * HWND -> PID resolution via Win32 GetWindowThreadProcessId.
  - Discord-style screen-source picker (thumbnail grid, screens vs
    apps tabs, live-refreshing thumbnails).
  - Hash routing fix for packaged builds (file:// can't resolve
    BrowserRouter paths).
  - Tauri sources removed (apps/desktop/src-tauri).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

apps/desktop/electron/modules/sql.ts

@@ -0,0 +1,93 @@
+// SQLite via better-sqlite3. One Database instance per renderer-tracked
+// handle; handles are keyed by the normalised db name (Tauri's plugin-sql
+// uses `sqlite:<name>` — we strip the prefix). Sync API is fine here
+// because the main process has its own event loop; better-sqlite3's
+// prepare/run/all are blocking but fast for typical chat-cache queries
+// (<1ms per op for the current workload).
+//
+// Binding param style: Tauri's plugin-sql used $1, $2... positionals with
+// bindings as an array. SQLite natively accepts $N so existing queries
+// keep working unmodified.
+
+import { app, ipcMain } from 'electron';
+import Database from 'better-sqlite3';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  CHANNELS,
+  type SqlExecuteArgs,
+  type SqlExecuteResult,
+  type SqlLoadArgs,
+  type SqlSelectArgs,
+  type SqlSelectResult,
+} from '../ipc-types';
+
+interface Handle {
+  db: Database.Database;
+  filePath: string;
+}
+
+const handles = new Map<string, Handle>();
+
+function stripPrefix(name: string): string {
+  return name.startsWith('sqlite:') ? name.slice('sqlite:'.length) : name;
+}
+
+function requireHandle(h: string): Handle {
+  const entry = handles.get(h);
+  if (!entry) throw new Error(`sql: unknown handle ${h}`);
+  return entry;
+}
+
+export function register(): void {
+  ipcMain.handle(CHANNELS.SQL_LOAD, async (_evt, args: SqlLoadArgs): Promise<string> => {
+    const rawName = stripPrefix(args.name);
+    const fileName = rawName.endsWith('.db') ? rawName : rawName + '.db';
+    const filePath = path.join(app.getPath('userData'), fileName);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const existing = handles.get(rawName);
+    if (existing) return rawName;
+    const db = new Database(filePath);
+    db.pragma('journal_mode = WAL');
+    handles.set(rawName, { db, filePath });
+    return rawName;
+  });
+
+  ipcMain.handle(
+    CHANNELS.SQL_EXECUTE,
+    async (_evt, args: SqlExecuteArgs): Promise<SqlExecuteResult> => {
+      const entry = requireHandle(args.handle);
+      const stmt = entry.db.prepare(args.query);
+      const info = stmt.run(...((args.bindings ?? []) as unknown[]));
+      return {
+        rowsAffected: info.changes,
+        lastInsertId:
+          typeof info.lastInsertRowid === 'bigint'
+            ? Number(info.lastInsertRowid)
+            : (info.lastInsertRowid ?? null),
+      };
+    },
+  );
+
+  ipcMain.handle(
+    CHANNELS.SQL_SELECT,
+    async (_evt, args: SqlSelectArgs): Promise<SqlSelectResult> => {
+      const entry = requireHandle(args.handle);
+      const stmt = entry.db.prepare(args.query);
+      const rows = stmt.all(...((args.bindings ?? []) as unknown[])) as Record<string, unknown>[];
+      return rows;
+    },
+  );
+
+  ipcMain.handle(CHANNELS.SQL_CLOSE, async (_evt, handle: string): Promise<void> => {
+    const entry = handles.get(handle);
+    if (!entry) return;
+    try {
+      entry.db.close();
+    } catch (err: unknown) {
+      console.warn('[sql] close failed', err);
+    }
+    handles.delete(handle);
+  });
+}