Initial commit: watch-together phases 0-4 + presence hardening, internet-tested

apps/desktop/.gitignore

@@ -0,0 +1,48 @@
+# Miscellaneous
+*.class
+*.log
+*.pyc
+*.swp
+.DS_Store
+.atom/
+.build/
+.buildlog/
+.history
+.svn/
+.swiftpm/
+migrate_working_dir/
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# The .vscode folder contains launch configuration and tasks you configure in
+# VS Code which you may wish to be included in version control, so this line
+# is commented out by default.
+#.vscode/
+
+# Flutter/Dart/Pub related
+**/doc/api/
+**/ios/Flutter/.last_build_id
+.dart_tool/
+.flutter-plugins-dependencies
+.pub-cache/
+.pub/
+/build/
+/coverage/
+
+# Symbolication related
+app.*.symbols
+
+# Obfuscation related
+app.*.map.json
+
+# Android Studio will place build artifacts here
+/android/app/debug
+/android/app/profile
+/android/app/release
+
+# Widget Preview related
+.widget_preview/

apps/desktop/.metadata

@@ -0,0 +1,33 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled and should not be manually edited.
+
+version:
+  revision: "e3005e3402d9cfa2043114c8bc53c59d12e9b98e"
+  channel: "beta"
+
+project_type: app
+
+# Tracks metadata for the flutter migrate command
+migration:
+  platforms:
+    - platform: root
+      create_revision: e3005e3402d9cfa2043114c8bc53c59d12e9b98e
+      base_revision: e3005e3402d9cfa2043114c8bc53c59d12e9b98e
+    - platform: linux
+      create_revision: e3005e3402d9cfa2043114c8bc53c59d12e9b98e
+      base_revision: e3005e3402d9cfa2043114c8bc53c59d12e9b98e
+    - platform: windows
+      create_revision: e3005e3402d9cfa2043114c8bc53c59d12e9b98e
+      base_revision: e3005e3402d9cfa2043114c8bc53c59d12e9b98e
+
+  # User provided section
+
+  # List of Local paths (relative to this file) that should be
+  # ignored by the migrate tool.
+  #
+  # Files that are not part of the templates will be ignored by default.
+  unmanaged_files:
+    - 'lib/main.dart'
+    - 'ios/Runner.xcodeproj/project.pbxproj'

apps/desktop/README.md

@@ -0,0 +1,17 @@
+# watch_together
+
+A new Flutter project.
+
+## Getting Started
+
+This project is a starting point for a Flutter application.
+
+A few resources to get you started if this is your first Flutter project:
+
+- [Learn Flutter](https://docs.flutter.dev/get-started/learn-flutter)
+- [Write your first Flutter app](https://docs.flutter.dev/get-started/codelab)
+- [Flutter learning resources](https://docs.flutter.dev/reference/learning-resources)
+
+For help getting started with Flutter development, view the
+[online documentation](https://docs.flutter.dev/), which offers tutorials,
+samples, guidance on mobile development, and a full API reference.

apps/desktop/analysis_options.yaml

@@ -0,0 +1,34 @@
+# This file configures the analyzer, which statically analyzes Dart code to
+# check for errors, warnings, and lints.
+#
+# The issues identified by the analyzer are surfaced in the UI of Dart-enabled
+# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be
+# invoked from the command line by running `flutter analyze`.
+
+# The following line activates a set of recommended lints for Flutter apps,
+# packages, and plugins designed to encourage good coding practices.
+include: package:flutter_lints/flutter.yaml
+
+analyzer:
+  exclude:
+    - build/**
+    - windows/**
+    - linux/**
+
+linter:
+  # The lint rules applied to this project can be customized in the
+  # section below to disable rules from the `package:flutter_lints/flutter.yaml`
+  # included above or to enable additional rules. A list of all available lints
+  # and their documentation is published at https://dart.dev/lints.
+  #
+  # Instead of disabling a lint rule for the entire project in the
+  # section below, it can also be suppressed for a single line of code
+  # or a specific dart file by using the `// ignore: name_of_lint` and
+  # `// ignore_for_file: name_of_lint` syntax on the line or in the file
+  # producing the lint.
+  rules:
+    # avoid_print: false  # Uncomment to disable the `avoid_print` rule
+    # prefer_single_quotes: true  # Uncomment to enable the `prefer_single_quotes` rule
+
+# Additional information about this file can be found at
+# https://dart.dev/guides/language/analysis-options

apps/desktop/lib/app.dart

@@ -0,0 +1,49 @@
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:signals/signals_flutter.dart';
+
+import 'src/screens/connect_screen.dart';
+import 'src/screens/legacy_session_screen.dart';
+import 'src/screens/minimal_session_screen.dart';
+import 'src/screens/nosheet_session_screen.dart';
+import 'src/screens/session_screen.dart';
+import 'src/screens/welcome_screen.dart';
+import 'src/state/session_state.dart';
+
+bool get useLegacySession =>
+    Platform.environment['SYNC_RELAY_UI'] == 'legacy';
+
+bool get useMinimalSession =>
+    Platform.environment['SYNC_RELAY_UI'] == 'minimal';
+
+bool get useNosheetSession =>
+    Platform.environment['SYNC_RELAY_UI'] == 'nosheet';
+
+class WatchTogetherApp extends StatelessWidget {
+  const WatchTogetherApp({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final session = SessionState.instance;
+    return MaterialApp(
+      title: 'Watch Together',
+      theme: ThemeData.dark(),
+      home: SignalBuilder(
+        builder: (context) {
+          return switch (session.route.value) {
+            AppRoute.welcome => const WelcomeScreen(),
+            AppRoute.connect => const ConnectScreen(),
+            AppRoute.session => useMinimalSession
+                ? const MinimalSessionScreen()
+                : useNosheetSession
+                    ? const NosheetSessionScreen()
+                    : useLegacySession
+                        ? const LegacySessionScreen()
+                        : const SessionScreen(),
+          };
+        },
+      ),
+    );
+  }
+}

apps/desktop/lib/main.dart

@@ -0,0 +1,50 @@
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:hive_ce_flutter/hive_flutter.dart';
+import 'package:media_kit/media_kit.dart';
+import 'package:sync_relay_core/core.dart';
+
+import 'app.dart';
+import 'src/state/session_state.dart';
+
+Future<void> main(List<String> args) async {
+  initLogging();
+  if (args.contains('--headless')) {
+    await runHeadless(args);
+    return;
+  }
+  FlutterError.onError = (details) {
+    debugPrint('FLUTTER ERROR: ${details.exceptionAsString()}\n${details.stack}');
+    FlutterError.presentError(details);
+  };
+  ErrorWidget.builder = (details) => Material(
+        color: const Color(0xFF101010),
+        child: Center(
+          child: Padding(
+            padding: const EdgeInsets.all(24),
+            child: Text(
+              'Something broke rendering this view:\n${details.exceptionAsString()}',
+              style: const TextStyle(color: Colors.white),
+              textAlign: TextAlign.center,
+            ),
+          ),
+        ),
+      );
+  WidgetsFlutterBinding.ensureInitialized();
+  await Hive.initFlutter();
+  try {
+    await SessionState.instance.loadForm();
+  } catch (e, st) {
+    debugPrint('load connect form failed: $e\n$st');
+  }
+  MediaKit.ensureInitialized();
+  runApp(const WatchTogetherApp());
+}
+
+Future<void> runHeadless(List<String> args) async {
+  final session = SessionState.instance;
+  await session.startHeadless(args);
+  await ProcessSignal.sigint.watch().first;
+  await session.stopServer();
+}

apps/desktop/lib/src/playback/playback_controller.dart

@@ -0,0 +1,102 @@
+import 'dart:io';
+
+import 'package:flutter/widgets.dart';
+import 'package:media_kit/media_kit.dart';
+
+import '../sync/room_diff.dart';
+
+class PlaybackController {
+  late final Player player;
+  bool _ready = false;
+
+  Future<void> init() async {
+    player = Player(
+        configuration: PlayerConfiguration(
+      bufferSize: 64 * 1024 * 1024,
+      vo: Platform.environment['SYNC_RELAY_VO'],
+    ));
+    _ready = true;
+    await _pinBufferProps();
+  }
+
+  Future<void> _pin(String property, String value) async {
+    try {
+      final dynamic platform = player.platform;
+      await platform?.setProperty(property, value);
+    } catch (e, st) {
+      debugPrint('pin $property=$value failed: $e\n$st');
+    }
+  }
+
+  Future<void> _pinBufferProps() async {
+    await _pin('demuxer-readahead-secs', '10');
+    await _pin('cache-secs', '10');
+    final hwdec = Platform.environment['SYNC_RELAY_HWDEC'];
+    if (hwdec != null && hwdec.isNotEmpty) {
+      await _pin('hwdec', hwdec);
+    }
+    await _pin('stream-lavf-o',
+        'reconnect_streamed=1,reconnect_on_http_error=1,reconnect_delay_max=4');
+  }
+
+  Future<void> openUrl(String url) async {
+    if (!_ready) return;
+    try {
+      await player.open(Media(url), play: false);
+    } catch (e, st) {
+      debugPrint('open $url failed: $e\n$st');
+      rethrow;
+    }
+  }
+
+  double get positionSecs =>
+      player.state.position.inMilliseconds / 1000.0;
+
+  double get bufferedSecsAhead {
+    final ahead =
+        (player.state.buffer - player.state.position).inMilliseconds / 1000.0;
+    if (ahead.isNaN || ahead < 0) return 0;
+    return ahead;
+  }
+
+  double get durationSecs =>
+      player.state.duration.inMilliseconds / 1000.0;
+
+  Future<void> apply(List<PlayerAction> actions) async {
+    for (final action in actions) {
+      try {
+        switch (action) {
+          case SeekAction(:final position):
+            if ((positionSecs - position).abs() < 0.5) break;
+            await player.seek(Duration(milliseconds: (position * 1000).round()));
+          case TransportAction(:final playing):
+            if (playing) {
+              await player.play();
+            } else {
+              await player.pause();
+            }
+          case RateAction(:final rate):
+            await player.setRate(rate);
+        }
+      } catch (e, st) {
+        debugPrint('player action $action failed: $e\n$st');
+      }
+    }
+  }
+
+  Future<void> dispose() async {
+    _ready = false;
+    try {
+      await player.dispose();
+    } catch (_) {}
+  }
+
+  Future<void> stop() async {
+    if (!_ready) return;
+    try {
+      await player.stop();
+    } catch (e, st) {
+      debugPrint('player stop failed: $e\n$st');
+    }
+  }
+}

apps/desktop/lib/src/screens/connect_screen.dart

@@ -0,0 +1,351 @@
+import 'dart:io';
+
+import 'package:file_picker/file_picker.dart';
+import 'package:flutter/material.dart';
+import 'package:signals/signals_flutter.dart';
+
+import '../session/session_coordinator.dart';
+import '../state/session_state.dart';
+import '../widgets/avatar_pipeline.dart';
+import '../widgets/media_input.dart';
+import '../widgets/user_section.dart';
+
+class ConnectScreen extends StatefulWidget {
+  const ConnectScreen({super.key});
+
+  @override
+  State<ConnectScreen> createState() => _ConnectScreenState();
+}
+
+class _ConnectScreenState extends State<ConnectScreen> {
+  late final TextEditingController _host;
+  late final TextEditingController _port;
+  late final TextEditingController _secret;
+  late final TextEditingController _name;
+  late final TextEditingController _media;
+  late final void Function() _stopKickWatch;
+  String? _error;
+  String? _notice;
+  bool _busy = false;
+  bool _dialogOpen = false;
+  int _attempt = 0;
+  String? _lastKickShown;
+
+  @override
+  void initState() {
+    super.initState();
+    final f = SessionState.instance.lastForm;
+    _host = TextEditingController(text: f.host);
+    _port = TextEditingController(text: f.port);
+    _secret = TextEditingController(text: f.secret);
+    _name = TextEditingController(text: f.name);
+    _media = TextEditingController(text: f.linkUrl.isNotEmpty ? f.linkUrl : f.mediaPath);
+    _stopKickWatch = effect(() {
+      final kick = SessionState.instance.coordinator.kickReason.value;
+      if (kick == null || kick.isEmpty) {
+        _lastKickShown = null;
+        return;
+      }
+      if (kick == _lastKickShown) return;
+      _lastKickShown = kick;
+      final reason = kick;
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        if (mounted) _showKickedDialog(reason);
+      });
+    });
+  }
+
+  @override
+  void dispose() {
+    _stopKickWatch();
+    _host.dispose();
+    _port.dispose();
+    _secret.dispose();
+    _name.dispose();
+    _media.dispose();
+    super.dispose();
+  }
+
+  String _actionable(Object e) {
+    if (e is FormatException) return e.message;
+    return 'check the form and try again';
+  }
+
+  Future<ConnectParams> _buildParams(ConnectMode mode) async {
+    final port = int.tryParse(_port.text.trim());
+    if (port == null || port <= 0 || port > 65535) {
+      throw const FormatException('port must be 1–65535');
+    }
+    if (_secret.text.isEmpty) {
+      throw const FormatException('room password required');
+    }
+    if (_name.text.trim().isEmpty) {
+      throw const FormatException('display name required');
+    }
+    String avatar = '';
+    try {
+      avatar = await encodeAvatar(SessionState.instance.lastForm.avatarPath);
+    } on FormatException catch (e) {
+      throw FormatException(e.message);
+    } catch (_) {
+      throw const FormatException('could not process that avatar — pick a PNG, JPG or WebP photo');
+    }
+    final parsed = parseMediaInput(_media.text);
+    if (mode == ConnectMode.host && parsed.mediaPath.isNotEmpty && !await File(parsed.mediaPath).exists()) {
+      throw const FormatException('media file not found — check the path or pick again with Browse');
+    }
+    return ConnectParams(
+      host: _host.text.trim().isEmpty ? '127.0.0.1' : _host.text.trim(),
+      port: port,
+      secret: _secret.text,
+      name: _name.text.trim(),
+      avatar: avatar,
+      mediaPath: mode == ConnectMode.host ? parsed.mediaPath : '',
+      linkUrl: mode == ConnectMode.host ? parsed.linkUrl : '',
+    );
+  }
+
+  Future<void> _submit(ConnectMode mode) async {
+    final myAttempt = ++_attempt;
+    final session = SessionState.instance;
+    setState(() {
+      _error = null;
+      _notice = null;
+      _busy = true;
+    });
+    late final ConnectParams params;
+    try {
+      params = await _buildParams(mode);
+    } catch (e) {
+      if (!mounted || myAttempt != _attempt) return;
+      setState(() {
+        _error = _actionable(e);
+        _busy = false;
+      });
+      return;
+    }
+    final parsed = parseMediaInput(_media.text);
+    final form = SessionState.instance.lastForm
+      ..host = _host.text.trim()
+      ..port = _port.text.trim()
+      ..secret = _secret.text
+      ..name = _name.text.trim()
+      ..mediaPath = parsed.mediaPath
+      ..linkUrl = parsed.linkUrl;
+    try {
+      if (mode == ConnectMode.host) {
+        await session.host(params, form);
+      } else {
+        await session.join(params, form);
+      }
+    } catch (e) {
+      if (!mounted || myAttempt != _attempt) return;
+      final kick = session.coordinator.kickReason.peek();
+      setState(() => _busy = false);
+      if (kick != null && kick.isNotEmpty) {
+        await _showKickedDialog(kick);
+      } else {
+        await _showConnectionDialog('$e');
+      }
+      return;
+    }
+    if (myAttempt != _attempt) {
+      try {
+        await session.leave();
+        await session.stopServer();
+      } catch (_) {}
+      return;
+    }
+    if (mounted) setState(() => _busy = false);
+  }
+
+  Future<void> _cancel() async {
+    _attempt++;
+    try {
+      await SessionState.instance.coordinator.cancelConnect();
+      await SessionState.instance.stopServer();
+    } catch (_) {}
+    if (!mounted) return;
+    setState(() {
+      _busy = false;
+      _notice = 'connection cancelled';
+    });
+  }
+
+  Future<void> _showKickedDialog(String reason) async {
+    if (!mounted || _dialogOpen) return;
+    _dialogOpen = true;
+    try {
+      await showDialog<void>(
+        context: context,
+        builder: (context) => AlertDialog(
+          title: const Text('You were removed'),
+          content: Text(reason.isEmpty ? 'The host removed you from the room.' : reason),
+          actions: [TextButton(onPressed: () => Navigator.pop(context), child: const Text('OK'))],
+        ),
+      );
+    } finally {
+      _dialogOpen = false;
+    }
+  }
+
+  Future<void> _showConnectionDialog(String message) async {
+    if (!mounted || _dialogOpen) return;
+    _dialogOpen = true;
+    try {
+      await showDialog<void>(
+        context: context,
+        builder: (context) => AlertDialog(
+          title: const Text('Could not connect'),
+          content: Text(message),
+          actions: [TextButton(onPressed: () => Navigator.pop(context), child: const Text('OK'))],
+        ),
+      );
+    } finally {
+      _dialogOpen = false;
+    }
+  }
+
+  Future<void> _browse(TextEditingController target, {required String dialogTitle, List<String>? allowedExtensions}) async {
+    try {
+      final files = await FilePicker.pickFiles(
+        dialogTitle: dialogTitle,
+        type: allowedExtensions == null ? FileType.any : FileType.custom,
+        allowedExtensions: allowedExtensions,
+      );
+      if (files.isEmpty) return;
+      final path = files.first.path;
+      if (path != null && mounted) setState(() => target.text = path);
+    } catch (e) {
+      if (!mounted) return;
+      setState(() => _notice = 'file dialog unavailable (${e.runtimeType}) — paste the path manually');
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final session = SessionState.instance;
+    return Scaffold(
+      appBar: AppBar(
+        leading: IconButton(icon: const Icon(Icons.arrow_back), onPressed: () => session.route.value = AppRoute.welcome),
+        title: SignalBuilder(builder: (context) => Text(session.connectMode.value == ConnectMode.host ? 'Host room' : 'Join room')),
+      ),
+      body: Stack(
+        alignment: AlignmentGeometry.center,
+        children: [
+          Align(
+            alignment: Alignment.bottomRight,
+            child: Padding(
+              padding: const EdgeInsets.all(20),
+              child: Card(
+                child: Padding(
+                  padding: const EdgeInsets.all(12),
+                  child: ConnectProfileCard(name: _name),
+                ),
+              ),
+            ),
+          ),
+          ConstrainedBox(
+            constraints: const BoxConstraints(maxWidth: 480),
+            child: ListView(
+              shrinkWrap: true,
+              padding: const EdgeInsets.all(24),
+              children: [
+                if (_error != null)
+                  Card(
+                    child: Padding(padding: const EdgeInsets.all(12), child: Text(_error!)),
+                  ),
+                if (_notice != null) Text(_notice!),
+                SignalBuilder(
+                  builder: (context) {
+                    final mode = session.connectMode.value;
+                    return SegmentedButton<ConnectMode>(
+                      segments: const [
+                        ButtonSegment(value: ConnectMode.host, label: Text('Host')),
+                        ButtonSegment(value: ConnectMode.join, label: Text('Join')),
+                      ],
+                      selected: {mode},
+                      onSelectionChanged: (s) => session.connectMode.value = s.first,
+                    );
+                  },
+                ),
+                const SizedBox(height: 16),
+                SignalBuilder(
+                  builder: (context) {
+                    if (session.connectMode.value == ConnectMode.host) {
+                      return const SizedBox.shrink();
+                    }
+                    return TextField(
+                      controller: _host,
+                      decoration: const InputDecoration(labelText: 'Host address'),
+                    );
+                  },
+                ),
+                TextField(
+                  controller: _port,
+                  decoration: const InputDecoration(labelText: 'Port'),
+                  keyboardType: TextInputType.number,
+                ),
+                TextField(
+                  controller: _secret,
+                  decoration: const InputDecoration(labelText: 'Room password'),
+                  obscureText: true,
+                ),
+                const SizedBox(height: 8),
+                SignalBuilder(
+                  builder: (context) {
+                    if (session.connectMode.value == ConnectMode.host) {
+                      return Row(
+                        children: [
+                          Expanded(
+                            child: TextField(
+                              controller: _media,
+                              decoration: const InputDecoration(labelText: 'Media (file path or http(s) URL)'),
+                            ),
+                          ),
+                          TextButton(
+                            onPressed: () => _browse(
+                              _media,
+                              dialogTitle: 'Pick media file',
+                              allowedExtensions: const ['mp4', 'mkv', 'webm', 'avi', 'mov', 'm4v', 'ts'],
+                            ),
+                            child: const Text('Browse'),
+                          ),
+                        ],
+                      );
+                    }
+                    return const SizedBox.shrink();
+                  },
+                ),
+                const SizedBox(height: 16),
+                SignalBuilder(
+                  builder: (context) {
+                    final mode = session.connectMode.value;
+                    return Column(
+                      crossAxisAlignment: CrossAxisAlignment.stretch,
+                      children: [
+                        ElevatedButton(
+                          onPressed: _busy ? null : () => _submit(mode),
+                          child: Text(
+                            _busy
+                                ? 'Connecting…'
+                                : mode == ConnectMode.host
+                                ? 'Start hosting'
+                                : 'Join',
+                          ),
+                        ),
+                        if (_busy) TextButton(onPressed: _cancel, child: const Text('Cancel')),
+                      ],
+                    );
+                  },
+                ),
+                const SizedBox(height: 12),
+                const Text('Host opens ports and serves. Clients open nothing.', textAlign: TextAlign.center),
+              ],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

apps/desktop/lib/src/screens/legacy_session_screen.dart

@@ -0,0 +1,151 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:media_kit_video/media_kit_video.dart';
+import 'package:signals/signals_flutter.dart';
+
+import '../state/session_state.dart';
+
+const _legacyControls = MaterialDesktopVideoControlsThemeData(
+  playAndPauseOnTap: false,
+  keyboardShortcuts: {},
+  bottomButtonBar: [
+    MaterialDesktopVolumeButton(),
+    MaterialDesktopPositionIndicator(),
+    Spacer(),
+    MaterialDesktopFullscreenButton(),
+  ],
+);
+
+class LegacySessionScreen extends StatefulWidget {
+  const LegacySessionScreen({super.key});
+
+  @override
+  State<LegacySessionScreen> createState() => _LegacySessionScreenState();
+}
+
+class _LegacySessionScreenState extends State<LegacySessionScreen> {
+  VideoController? _video;
+  final _focus = FocusNode();
+
+  @override
+  void initState() {
+    super.initState();
+    _video = VideoController(
+        SessionState.instance.coordinator.playback.player);
+  }
+
+  @override
+  void dispose() {
+    _focus.dispose();
+    super.dispose();
+  }
+
+  KeyEventResult _onKey(FocusNode node, KeyEvent event) {
+    if (event is! KeyDownEvent) return KeyEventResult.ignored;
+    if (event.logicalKey == LogicalKeyboardKey.space) {
+      SessionState.instance.coordinator.toggleReady();
+      return KeyEventResult.handled;
+    }
+    return KeyEventResult.ignored;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final session = SessionState.instance;
+    final coord = session.coordinator;
+    return Focus(
+      focusNode: _focus,
+      autofocus: true,
+      onKeyEvent: _onKey,
+      child: Scaffold(
+        appBar: AppBar(
+          title: SignalBuilder(
+            builder: (context) {
+              final h = coord.health.value;
+              final r = coord.room.value;
+              return Text('Room · ${r?.transport ?? '…'} · ${h.message}');
+            },
+          ),
+          actions: [
+            IconButton(
+              icon: const Icon(Icons.logout),
+              onPressed: () => session.leave(),
+            ),
+          ],
+        ),
+        body: Column(
+          children: [
+            SignalBuilder(builder: (context) {
+              final h = coord.health.value;
+              final starve = coord.starving.value;
+              final text = [
+                h.message,
+                if (starve != null) starve,
+              ].join(' · ');
+              return Container(
+                width: double.infinity,
+                padding:
+                    const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+                child: Text(text),
+              );
+            }),
+            Expanded(
+              child: _video == null
+                  ? const Center(child: Text('player starting…'))
+                  : MaterialDesktopVideoControlsTheme(
+                      normal: _legacyControls,
+                      fullscreen: _legacyControls,
+                      child: Video(controller: _video!),
+                    ),
+            ),
+            SignalBuilder(builder: (context) {
+              final r = coord.room.value;
+              if (r == null) return const SizedBox.shrink();
+              return Padding(
+                padding: const EdgeInsets.all(8),
+                child: Wrap(
+                  spacing: 8,
+                  children: [
+                    for (final m in r.members)
+                      Chip(
+                        avatar: CircleAvatar(
+                          child: Text(m.name.isEmpty
+                              ? '?'
+                              : m.name[0].toUpperCase()),
+                        ),
+                        label: Text(m.name),
+                        backgroundColor: m.ready
+                            ? Colors.green.withValues(alpha: 0.3)
+                            : null,
+                      ),
+                  ],
+                ),
+              );
+            }),
+            Padding(
+              padding: const EdgeInsets.only(bottom: 12),
+              child: Row(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  SignalBuilder(builder: (context) {
+                    final ready =
+                        coord.selfMember.value?.ready ?? false;
+                    return ElevatedButton(
+                      onPressed: () => coord.toggleReady(),
+                      child: Text(ready ? 'Ready ✓' : 'Not ready'),
+                    );
+                  }),
+                  const SizedBox(width: 12),
+                  OutlinedButton(
+                    onPressed: () => coord.forcePlayAll(),
+                    child: const Text('Force play all'),
+                  ),
+                ],
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

apps/desktop/lib/src/screens/minimal_session_screen.dart

@@ -0,0 +1,125 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:media_kit_video/media_kit_video.dart';
+import 'package:signals/signals_flutter.dart';
+
+import '../state/session_state.dart';
+
+const _minimalControls = MaterialDesktopVideoControlsThemeData(
+  playAndPauseOnTap: false,
+  keyboardShortcuts: {},
+  bottomButtonBar: [
+    MaterialDesktopVolumeButton(),
+    _ReadyButton(),
+    _MarkAllButton(),
+    MaterialDesktopPositionIndicator(),
+    Spacer(),
+    MaterialDesktopFullscreenButton(),
+  ],
+);
+
+class MinimalSessionScreen extends StatefulWidget {
+  const MinimalSessionScreen({super.key});
+
+  @override
+  State<MinimalSessionScreen> createState() => _MinimalSessionScreenState();
+}
+
+class _MinimalSessionScreenState extends State<MinimalSessionScreen> {
+  VideoController? _video;
+
+  @override
+  void initState() {
+    super.initState();
+    _video = VideoController(
+        SessionState.instance.coordinator.playback.player);
+    HardwareKeyboard.instance.addHandler(_key);
+  }
+
+  @override
+  void dispose() {
+    HardwareKeyboard.instance.removeHandler(_key);
+    super.dispose();
+  }
+
+  bool _key(KeyEvent event) {
+    if (event is! KeyDownEvent) return false;
+    if (SessionState.instance.route.peek() != AppRoute.session) {
+      return false;
+    }
+    if (event.logicalKey == LogicalKeyboardKey.space) {
+      SessionState.instance.coordinator.toggleReady();
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      backgroundColor: Colors.black,
+      body: Stack(
+        children: [
+          Positioned.fill(
+            child: _video == null
+                ? const Center(child: Text('player starting…'))
+                : MaterialDesktopVideoControlsTheme(
+                    normal: _minimalControls,
+                    fullscreen: _minimalControls,
+                    child: Video(controller: _video!),
+                  ),
+          ),
+          const Positioned(
+            top: 8,
+            right: 8,
+            child: Text('MINIMAL',
+                style: TextStyle(color: Colors.red, fontSize: 12)),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class _ReadyButton extends StatelessWidget {
+  const _ReadyButton();
+
+  @override
+  Widget build(BuildContext context) {
+    return SignalBuilder(
+      builder: (context) {
+        final ready = SessionState
+                .instance.coordinator.selfMember.value?.ready ??
+            false;
+        return TextButton(
+          style: TextButton.styleFrom(
+            foregroundColor: Colors.white,
+            tapTargetSize: MaterialTapTargetSize.shrinkWrap,
+          ),
+          onPressed: () =>
+              SessionState.instance.coordinator.toggleReady(),
+          child: Text(ready ? 'Ready ✓' : 'Not ready',
+              style: const TextStyle(fontSize: 12)),
+        );
+      },
+    );
+  }
+}
+
+class _MarkAllButton extends StatelessWidget {
+  const _MarkAllButton();
+
+  @override
+  Widget build(BuildContext context) {
+    return TextButton(
+      style: TextButton.styleFrom(
+        foregroundColor: Colors.white,
+        tapTargetSize: MaterialTapTargetSize.shrinkWrap,
+      ),
+      onPressed: () =>
+          SessionState.instance.coordinator.forcePlayAll(),
+      child: const Text('Mark everyone ready',
+          style: TextStyle(fontSize: 12)),
+    );
+  }
+}

apps/desktop/lib/src/screens/nosheet_session_screen.dart

@@ -0,0 +1,208 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:media_kit_video/media_kit_video.dart';
+import 'package:signals/signals_flutter.dart';
+
+import '../session/health.dart';
+import '../state/session_state.dart';
+import '../widgets/member_avatar.dart';
+
+const _nosheetControls = MaterialDesktopVideoControlsThemeData(
+  playAndPauseOnTap: false,
+  keyboardShortcuts: {},
+  visibleOnMount: true,
+  hideMouseOnControlsRemoval: false,
+  controlsHoverDuration: Duration(hours: 24),
+  bottomButtonBar: [
+    MaterialDesktopVolumeButton(),
+    _ReadyButton(),
+    _MarkAllButton(),
+    MaterialDesktopPositionIndicator(),
+    Spacer(),
+    MaterialDesktopFullscreenButton(),
+  ],
+);
+
+class NosheetSessionScreen extends StatefulWidget {
+  const NosheetSessionScreen({super.key});
+
+  @override
+  State<NosheetSessionScreen> createState() => _NosheetSessionScreenState();
+}
+
+class _NosheetSessionScreenState extends State<NosheetSessionScreen> {
+  VideoController? _video;
+
+  @override
+  void initState() {
+    super.initState();
+    _video = VideoController(
+        SessionState.instance.coordinator.playback.player);
+    HardwareKeyboard.instance.addHandler(_key);
+  }
+
+  @override
+  void dispose() {
+    HardwareKeyboard.instance.removeHandler(_key);
+    super.dispose();
+  }
+
+  bool _key(KeyEvent event) {
+    if (event is! KeyDownEvent) return false;
+    if (SessionState.instance.route.peek() != AppRoute.session) {
+      return false;
+    }
+    if (event.logicalKey == LogicalKeyboardKey.space) {
+      SessionState.instance.coordinator.toggleReady();
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final coord = SessionState.instance.coordinator;
+    return Scaffold(
+      backgroundColor: Colors.black,
+      body: Stack(
+        children: [
+          Positioned.fill(
+            child: _video == null
+                ? const Center(child: Text('player starting…'))
+                : MaterialDesktopVideoControlsTheme(
+                    normal: _nosheetControls,
+                    fullscreen: _nosheetControls,
+                    child: Video(controller: _video!),
+                  ),
+          ),
+          const Positioned(
+            top: 8,
+            right: 8,
+            child: Text('NOSHEET',
+                style: TextStyle(color: Colors.red, fontSize: 12)),
+          ),
+          Positioned(
+            top: 12,
+            left: 12,
+            child: SignalBuilder(builder: (context) {
+              final h = coord.health.value;
+              final starve = coord.starving.value;
+              final retrying = coord.reconnecting.value;
+              final unwell = h.severity == HealthSeverity.warn ||
+                  h.severity == HealthSeverity.error ||
+                  retrying ||
+                  starve != null;
+              if (!unwell) return const SizedBox.shrink();
+              return Container(
+                decoration: BoxDecoration(
+                  color: Colors.black.withValues(alpha: 0.65),
+                  borderRadius: BorderRadius.circular(999),
+                ),
+                padding:
+                    const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+                child: Text(
+                  [h.message, if (starve != null) starve].join(' · '),
+                  style: const TextStyle(color: Colors.white, fontSize: 12),
+                ),
+              );
+            }),
+          ),
+          SignalBuilder(builder: (context) {
+            final r = coord.room.value;
+            if (r == null || r.transport != 'held') {
+              return const SizedBox.shrink();
+            }
+            final waiting = [
+              for (final m in r.members)
+                if (!m.ready) m
+            ];
+            if (waiting.isEmpty) return const SizedBox.shrink();
+            return Positioned.fill(
+              child: IgnorePointer(
+                child: Center(
+                  child: Wrap(
+                    spacing: -20,
+                    children: [
+                      for (final m in waiting)
+                        Opacity(
+                          opacity: m.stale ? 0.5 : 1.0,
+                          child: MemberAvatar(
+                            avatarBase64: m.avatar,
+                            name: m.name,
+                            size: 64,
+                          ),
+                        ),
+                    ],
+                  ),
+                ),
+              ),
+            );
+          }),
+          Positioned(
+            right: 12,
+            top: 56,
+            child: SignalBuilder(builder: (context) {
+              final items = coord.toasts.value;
+              return Column(
+                crossAxisAlignment: CrossAxisAlignment.end,
+                children: [
+                  for (final t in items.reversed.take(5))
+                    Card(
+                      child: Padding(
+                        padding: const EdgeInsets.symmetric(
+                            horizontal: 12, vertical: 8),
+                        child: Text(t.text),
+                      ),
+                    ),
+                ],
+              );
+            }),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class _ReadyButton extends StatelessWidget {
+  const _ReadyButton();
+
+  @override
+  Widget build(BuildContext context) {
+    return SignalBuilder(
+      builder: (context) {
+        final ready = SessionState
+                .instance.coordinator.selfMember.value?.ready ??
+            false;
+        return TextButton(
+          style: TextButton.styleFrom(
+            foregroundColor: Colors.white,
+            tapTargetSize: MaterialTapTargetSize.shrinkWrap,
+          ),
+          onPressed: () =>
+              SessionState.instance.coordinator.toggleReady(),
+          child: Text(ready ? 'Ready ✓' : 'Not ready',
+              style: const TextStyle(fontSize: 12)),
+        );
+      },
+    );
+  }
+}
+
+class _MarkAllButton extends StatelessWidget {
+  const _MarkAllButton();
+
+  @override
+  Widget build(BuildContext context) {
+    return TextButton(
+      style: TextButton.styleFrom(
+        foregroundColor: Colors.white,
+        tapTargetSize: MaterialTapTargetSize.shrinkWrap,
+      ),
+      onPressed: () =>
+          SessionState.instance.coordinator.forcePlayAll(),
+      child: const Text('Mark everyone ready',
+          style: TextStyle(fontSize: 12)),
+    );
+  }
+}

apps/desktop/lib/src/screens/session_screen.dart

@@ -0,0 +1,580 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:media_kit_video/media_kit_video.dart';
+import 'package:signals/signals_flutter.dart';
+
+import '../session/health.dart';
+import '../state/session_state.dart';
+import '../widgets/dialogs.dart';
+import '../widgets/member_avatar.dart';
+
+class SessionScreen extends StatefulWidget {
+  const SessionScreen({super.key});
+
+  @override
+  State<SessionScreen> createState() => _SessionScreenState();
+}
+
+class _SessionScreenState extends State<SessionScreen> {
+  VideoController? _video;
+  bool _sheetOpen = false;
+  bool _confirmLeave = false;
+  DateTime? _lastKeyAt;
+  final _chat = TextEditingController();
+  final _swapLink = TextEditingController();
+  late final void Function() _stopKickWatch;
+  late final FocusNode _noFocus;
+
+  @override
+  void initState() {
+    super.initState();
+    final session = SessionState.instance;
+    _noFocus = FocusNode(skipTraversal: true, canRequestFocus: false);
+    _video = VideoController(session.coordinator.playback.player);
+    HardwareKeyboard.instance.addHandler(_globalKey);
+    _stopKickWatch = effect(() {
+      if (session.coordinator.kickReason.value != null) {
+        session.route.value = AppRoute.connect;
+      }
+    });
+  }
+
+  @override
+  void dispose() {
+    HardwareKeyboard.instance.removeHandler(_globalKey);
+    _stopKickWatch();
+    _chat.dispose();
+    _swapLink.dispose();
+    _noFocus.dispose();
+    super.dispose();
+  }
+
+  bool get _editing {
+    var n = FocusManager.instance.primaryFocus;
+    while (n != null) {
+      final w = n.context?.widget;
+      if (w is EditableText) return true;
+      n = n.parent;
+    }
+    return false;
+  }
+
+  bool _globalKey(KeyEvent event) {
+    if (event is! KeyDownEvent) return false;
+    if (SessionState.instance.route.peek() != AppRoute.session) return false;
+    if (_editing) return false;
+    final now = DateTime.now().toUtc();
+    if (_lastKeyAt != null && now.difference(_lastKeyAt!).inMilliseconds < 350) {
+      return false;
+    }
+    final coord = SessionState.instance.coordinator;
+    if (event.logicalKey == LogicalKeyboardKey.space) {
+      _lastKeyAt = now;
+      coord.toggleReady();
+      return true;
+    }
+    if (event.logicalKey == LogicalKeyboardKey.tab) {
+      if (!mounted) return false;
+      _lastKeyAt = now;
+      setState(() => _sheetOpen = !_sheetOpen);
+      coord.markInput();
+      return true;
+    }
+    if (event.logicalKey == LogicalKeyboardKey.arrowRight) {
+      _lastKeyAt = now;
+      coord.nudge(10);
+      return true;
+    }
+    if (event.logicalKey == LogicalKeyboardKey.arrowLeft) {
+      _lastKeyAt = now;
+      coord.nudge(-10);
+      return true;
+    }
+    if (event.logicalKey == LogicalKeyboardKey.escape) {
+      if (!mounted) return false;
+      if (_sheetOpen) {
+        setState(() => _sheetOpen = false);
+        return true;
+      }
+      _lastKeyAt = now;
+      setState(() => _confirmLeave = true);
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final session = SessionState.instance;
+    final coord = session.coordinator;
+    final controlsTheme = MaterialDesktopVideoControlsThemeData(
+      playAndPauseOnTap: false,
+      keyboardShortcuts: {},
+      visibleOnMount: true,
+      hideMouseOnControlsRemoval: false,
+      controlsHoverDuration: const Duration(hours: 24),
+      bottomButtonBar: [
+        const MaterialDesktopVolumeButton(),
+        _ReadyControlButton(focusNode: _noFocus),
+        _MarkAllReadyControlButton(focusNode: _noFocus),
+        const MaterialDesktopPositionIndicator(),
+        const Spacer(),
+        const MaterialDesktopFullscreenButton(),
+      ],
+    );
+    return Scaffold(
+      backgroundColor: Colors.black,
+      body: Stack(
+        children: [
+          Positioned.fill(
+            child: _video == null
+                ? const Center(
+                    child: Text('player starting…', style: TextStyle(color: Colors.white)),
+                  )
+                : MaterialDesktopVideoControlsTheme(
+                    normal: controlsTheme,
+                    fullscreen: controlsTheme,
+                    child: Video(controller: _video!),
+                  ),
+          ),
+          Positioned(
+            top: 0,
+            right: 0,
+            child: Container(
+              color: Colors.black.withValues(alpha: 0.6),
+              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+              child: Row(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  IconButton(
+                    icon: const Icon(Icons.group, color: Colors.white),
+                    onPressed: () {
+                      setState(() => _sheetOpen = !_sheetOpen);
+                      coord.markInput();
+                    },
+                  ),
+                ],
+              ),
+            ),
+          ),
+          Positioned(
+            top: 12,
+            left: 12,
+            child: SignalBuilder(
+              builder: (context) {
+                final h = coord.health.value;
+                final starve = coord.starving.value;
+                final retrying = coord.reconnecting.value;
+                final kicked = coord.kickReason.value;
+                final unwell = h.severity == HealthSeverity.warn || h.severity == HealthSeverity.error || retrying || starve != null;
+                if (!unwell) return const SizedBox.shrink();
+                final color = switch (h.severity) {
+                  HealthSeverity.ok => Colors.green,
+                  HealthSeverity.info => Colors.grey,
+                  HealthSeverity.warn => Colors.orange,
+                  HealthSeverity.error => Colors.red,
+                };
+                final IconData icon;
+                if (retrying) {
+                  icon = Icons.sync;
+                } else if (h.severity == HealthSeverity.error) {
+                  icon = Icons.error_outline;
+                } else if (h.severity == HealthSeverity.warn) {
+                  icon = Icons.warning_amber_outlined;
+                } else {
+                  icon = Icons.hourglass_empty;
+                }
+                final text = [h.message, if (starve != null) starve, if (retrying) 'reconnecting…'].join(' · ');
+                final canRetry = !retrying && kicked == null && (h.severity == HealthSeverity.error || h.severity == HealthSeverity.warn);
+                return Container(
+                  decoration: BoxDecoration(color: Colors.black.withValues(alpha: 0.65), borderRadius: BorderRadius.circular(999)),
+                  padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+                  child: Row(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      Icon(icon, color: color, size: 16),
+                      const SizedBox(width: 8),
+                      Flexible(
+                        child: Text(text, style: const TextStyle(color: Colors.white, fontSize: 12)),
+                      ),
+                      if (retrying)
+                        TextButton(
+                          style: TextButton.styleFrom(foregroundColor: Colors.white, tapTargetSize: MaterialTapTargetSize.shrinkWrap),
+                          onPressed: () => coord.cancelReconnect(),
+                          child: const Text('Cancel', style: TextStyle(fontSize: 12)),
+                        ),
+                      if (canRetry)
+                        TextButton(
+                          style: TextButton.styleFrom(foregroundColor: Colors.white, tapTargetSize: MaterialTapTargetSize.shrinkWrap),
+                          onPressed: () => coord.retry(),
+                          child: const Text('Retry', style: TextStyle(fontSize: 12)),
+                        ),
+                    ],
+                  ),
+                );
+              },
+            ),
+          ),
+          SignalBuilder(
+            builder: (context) {
+              final r = coord.room.value;
+              final waiting = [
+                for (final m in r?.members ?? [])
+                  if (!m.ready) m,
+              ];
+              final show = r != null && r.transport == 'held' && waiting.isNotEmpty;
+              return Positioned.fill(
+                child: IgnorePointer(
+                  child: Center(
+                    child: Visibility(
+                      visible: show,
+                      maintainState: true,
+                      maintainAnimation: true,
+                      maintainSize: true,
+                      child: Container(
+                        decoration: BoxDecoration(
+                          color: Colors.black.withValues(alpha: 0.7),
+                          borderRadius: BorderRadiusGeometry.circular(20),
+                        ),
+                        child: Padding(
+                          padding: const EdgeInsets.all(8.0),
+                          child: Column(
+                            mainAxisSize: .min,
+                            spacing: 10,
+                            crossAxisAlignment: .center,
+                            children: [
+                              Text("Waiting for", style: TextTheme.of(context).labelLarge),
+                              Wrap(
+                                alignment: WrapAlignment.center,
+                                spacing: -20,
+                                runSpacing: 8,
+                                children: [
+                                  for (final m in waiting)
+                                    Opacity(
+                                      opacity: m.stale ? 0.5 : 1.0,
+                                      child: MemberAvatar(avatarBase64: m.avatar, name: m.name, size: 96),
+                                    ),
+                                ],
+                              ),
+                            ],
+                          ),
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+              );
+            },
+          ),
+          Positioned(
+            right: 12,
+            top: 56,
+            child: SignalBuilder(
+              builder: (context) {
+                final items = coord.toasts.value;
+                return Column(
+                  crossAxisAlignment: CrossAxisAlignment.end,
+                  children: [for (final t in items.reversed.take(5)) _ToastCard(key: ValueKey(t.id), text: t.text)],
+                );
+              },
+            ),
+          ),
+          Positioned.fill(
+            child: IgnorePointer(
+              ignoring: !_sheetOpen,
+              child: AnimatedOpacity(
+                duration: const Duration(milliseconds: 200),
+                opacity: _sheetOpen ? 1 : 0,
+                child: GestureDetector(
+                  onTap: () => setState(() => _sheetOpen = false),
+                  child: Container(color: Colors.black54),
+                ),
+              ),
+            ),
+          ),
+          Positioned(
+            top: 0,
+            bottom: 0,
+            right: 0,
+            child: IgnorePointer(
+              ignoring: !_sheetOpen,
+              child: AnimatedSlide(
+                duration: const Duration(milliseconds: 250),
+                curve: Curves.easeOut,
+                offset: _sheetOpen ? Offset.zero : const Offset(1, 0),
+                child: SizedBox(
+                  width: 380,
+                  height: double.infinity,
+                  child: _SheetPanel(
+                    chat: _chat,
+                    swapLink: _swapLink,
+                    onClose: () => setState(() => _sheetOpen = false),
+                    onLeave: () => setState(() {
+                      _sheetOpen = false;
+                      _confirmLeave = true;
+                    }),
+                  ),
+                ),
+              ),
+            ),
+          ),
+          if (_confirmLeave)
+            Positioned.fill(
+              child: GestureDetector(
+                onTap: () => setState(() => _confirmLeave = false),
+                child: Container(
+                  color: Colors.black54,
+                  child: Center(
+                    child: GestureDetector(
+                      onTap: () {},
+                      child: AlertDialog(
+                        title: const Text('Leave room?'),
+                        content: const Text('You can rejoin right away.'),
+                        actions: [
+                          TextButton(onPressed: () => setState(() => _confirmLeave = false), child: const Text('Cancel')),
+                          TextButton(
+                            onPressed: () {
+                              setState(() => _confirmLeave = false);
+                              session.leave();
+                            },
+                            child: const Text('Leave'),
+                          ),
+                        ],
+                      ),
+                    ),
+                  ),
+                ),
+              ),
+            ),
+        ],
+      ),
+    );
+  }
+}
+
+class _ReadyControlButton extends StatelessWidget {
+  final FocusNode focusNode;
+  const _ReadyControlButton({required this.focusNode});
+
+  @override
+  Widget build(BuildContext context) {
+    return SignalBuilder(
+      builder: (context) {
+        final ready = SessionState.instance.coordinator.selfMember.value?.ready ?? false;
+        return TextButton(
+          focusNode: focusNode,
+          style: TextButton.styleFrom(
+            foregroundColor: Colors.white,
+            padding: const EdgeInsets.symmetric(horizontal: 8),
+            tapTargetSize: MaterialTapTargetSize.shrinkWrap,
+          ),
+          onPressed: () => SessionState.instance.coordinator.toggleReady(),
+          child: Text(ready ? 'Ready ✓' : 'Not ready', style: const TextStyle(fontSize: 12)),
+        );
+      },
+    );
+  }
+}
+
+class _MarkAllReadyControlButton extends StatelessWidget {
+  final FocusNode focusNode;
+  const _MarkAllReadyControlButton({required this.focusNode});
+
+  @override
+  Widget build(BuildContext context) {
+    return TextButton(
+      focusNode: focusNode,
+      style: TextButton.styleFrom(
+        foregroundColor: Colors.white,
+        padding: const EdgeInsets.symmetric(horizontal: 8),
+        tapTargetSize: MaterialTapTargetSize.shrinkWrap,
+      ),
+      onPressed: () => SessionState.instance.coordinator.forcePlayAll(),
+      child: const Text('Mark everyone ready', style: TextStyle(fontSize: 12)),
+    );
+  }
+}
+
+class _ToastCard extends StatefulWidget {
+  final String text;
+  const _ToastCard({super.key, required this.text});
+
+  @override
+  State<_ToastCard> createState() => _ToastCardState();
+}
+
+class _ToastCardState extends State<_ToastCard> {
+  bool _shown = false;
+
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (mounted) setState(() => _shown = true);
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AnimatedSlide(
+      duration: const Duration(milliseconds: 250),
+      curve: Curves.easeOut,
+      offset: _shown ? Offset.zero : const Offset(1, 0),
+      child: AnimatedOpacity(
+        duration: const Duration(milliseconds: 250),
+        opacity: _shown ? 1 : 0,
+        child: Card(
+          child: Padding(padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8), child: Text(widget.text)),
+        ),
+      ),
+    );
+  }
+}
+
+class _SheetPanel extends StatelessWidget {
+  final TextEditingController chat;
+  final TextEditingController swapLink;
+  final VoidCallback onClose;
+  final VoidCallback onLeave;
+  const _SheetPanel({required this.chat, required this.swapLink, required this.onClose, required this.onLeave});
+
+  @override
+  Widget build(BuildContext context) {
+    final session = SessionState.instance;
+    final coord = session.coordinator;
+    return Material(
+      elevation: 8,
+      child: Padding(
+        padding: const EdgeInsets.fromLTRB(16, 12, 16, 16),
+        child: SignalBuilder(
+          builder: (context) {
+            final r = coord.room.value;
+            final log = coord.feedLog.value;
+            final theme = Theme.of(context);
+            final sectionStyle = theme.textTheme.titleSmall?.copyWith(fontWeight: FontWeight.bold);
+            return ListView(
+              children: [
+                Row(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Expanded(
+                      child: Column(
+                        crossAxisAlignment: CrossAxisAlignment.start,
+                        children: [
+                          Text('Room', style: theme.textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
+                          const SizedBox(height: 2),
+                          Text(
+                            'transport ${r?.transport ?? '…'} · event ${r?.eventId ?? 0} · media ${r?.mediaId ?? 0}',
+                            style: theme.textTheme.bodySmall,
+                          ),
+                        ],
+                      ),
+                    ),
+                    IconButton(icon: const Icon(Icons.close), onPressed: onClose),
+                  ],
+                ),
+                const Divider(height: 20),
+                Text('Users (${r?.members.length ?? 0})', style: sectionStyle),
+                const SizedBox(height: 6),
+                if (r != null)
+                  for (final m in r.members)
+                    Card(
+                      margin: const EdgeInsets.symmetric(vertical: 4),
+                      child: ListTile(
+                        dense: true,
+                        leading: MemberAvatar(avatarBase64: m.avatar, name: m.name, size: 36),
+                        title: Text(m.id == coord.sync.memberId ? '${m.name} (you)' : m.name),
+                        subtitle: Text('ready=${m.ready} inSet=${m.inSet} buf=${m.buffered.toStringAsFixed(1)} stale=${m.stale}'),
+                        trailing: Row(
+                          mainAxisSize: MainAxisSize.min,
+                          children: [
+                            TextButton(
+                              onPressed: () => coord.forceTarget(m.id, !m.ready),
+                              child: Text(m.ready ? 'Force unready' : 'Force ready'),
+                            ),
+                            TextButton(
+                              onPressed: () async {
+                                final ok = await showKickConfirmDialog(context, m.name);
+                                if (ok == true) coord.kick(m.id);
+                              },
+                              child: const Text('Kick'),
+                            ),
+                          ],
+                        ),
+                      ),
+                    ),
+                const Divider(height: 20),
+                Text('Log', style: sectionStyle),
+                const SizedBox(height: 6),
+                if (log.isEmpty) Text('No events yet', style: theme.textTheme.bodySmall),
+                for (final f in log.reversed.take(30))
+                  Padding(
+                    padding: const EdgeInsets.symmetric(vertical: 2),
+                    child: Text('${f.actor} ${f.action} ${f.target ?? ''}', style: theme.textTheme.bodySmall),
+                  ),
+                const Divider(height: 20),
+                Text('Chat', style: sectionStyle),
+                const SizedBox(height: 8),
+                Row(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Expanded(
+                      child: TextField(
+                        controller: chat,
+                        decoration: const InputDecoration(labelText: 'Chat message', border: OutlineInputBorder(), isDense: true),
+                        onSubmitted: (v) {
+                          coord.sendChat(v);
+                          chat.clear();
+                        },
+                      ),
+                    ),
+                    const SizedBox(width: 8),
+                    IconButton(
+                      icon: const Icon(Icons.send),
+                      onPressed: () {
+                        coord.sendChat(chat.text);
+                        chat.clear();
+                      },
+                    ),
+                  ],
+                ),
+                const SizedBox(height: 12),
+                Text('Share a link', style: sectionStyle),
+                const SizedBox(height: 8),
+                Row(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Expanded(
+                      child: TextField(
+                        controller: swapLink,
+                        decoration: const InputDecoration(labelText: 'Swap to link URL', border: OutlineInputBorder(), isDense: true),
+                      ),
+                    ),
+                    const SizedBox(width: 8),
+                    IconButton(
+                      icon: const Icon(Icons.swap_horiz),
+                      onPressed: () {
+                        coord.swapLink(swapLink.text.trim());
+                        swapLink.clear();
+                      },
+                    ),
+                  ],
+                ),
+                const Divider(height: 20),
+                SizedBox(
+                  width: double.infinity,
+                  child: OutlinedButton.icon(
+                    style: OutlinedButton.styleFrom(foregroundColor: theme.colorScheme.error),
+                    icon: const Icon(Icons.logout),
+                    label: const Text('Leave room'),
+                    onPressed: onLeave,
+                  ),
+                ),
+              ],
+            );
+          },
+        ),
+      ),
+    );
+  }
+}

apps/desktop/lib/src/screens/welcome_screen.dart

@@ -0,0 +1,50 @@
+import 'package:flutter/material.dart';
+
+import '../state/session_state.dart';
+
+class WelcomeScreen extends StatelessWidget {
+  const WelcomeScreen({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final session = SessionState.instance;
+    return Scaffold(
+      body: Center(
+        child: ConstrainedBox(
+          constraints: const BoxConstraints(maxWidth: 420),
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              const Text('Watch Together', style: TextStyle(fontSize: 24)),
+              const SizedBox(height: 8),
+              const Text(
+                'Set your name + avatar on the next screen.',
+                textAlign: TextAlign.center,
+              ),
+              const SizedBox(height: 24),
+              Row(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  ElevatedButton(
+                    onPressed: () => session.goConnect(ConnectMode.host),
+                    child: const Text('Host'),
+                  ),
+                  const SizedBox(width: 16),
+                  ElevatedButton(
+                    onPressed: () => session.goConnect(ConnectMode.join),
+                    child: const Text('Join'),
+                  ),
+                ],
+              ),
+              const SizedBox(height: 12),
+              const Text(
+                'Host opens ports and serves. Clients open nothing.',
+                textAlign: TextAlign.center,
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

apps/desktop/lib/src/session/health.dart

@@ -0,0 +1,7 @@
+enum HealthSeverity { ok, info, warn, error }
+
+class HealthStatus {
+  final HealthSeverity severity;
+  final String message;
+  const HealthStatus(this.severity, this.message);
+}

apps/desktop/lib/src/session/session_coordinator.dart

@@ -0,0 +1,603 @@
+import 'dart:async';
+
+import 'package:flutter/widgets.dart';
+import 'package:signals/signals_flutter.dart';
+import 'package:sync_relay_core/core.dart';
+
+import '../playback/playback_controller.dart';
+import '../sfx/sfx.dart';
+import '../sync/room_diff.dart';
+import '../sync/sync_client.dart';
+import 'health.dart';
+
+class ConnectParams {
+  final String host;
+  final int port;
+  final String secret;
+  final String name;
+  final String avatar;
+  final String mediaPath;
+  final String linkUrl;
+  const ConnectParams({
+    required this.host,
+    required this.port,
+    required this.secret,
+    required this.name,
+    this.avatar = '',
+    this.mediaPath = '',
+    this.linkUrl = '',
+  });
+}
+
+class ToastItem {
+  final int id;
+  final String text;
+  final DateTime at;
+  const ToastItem({required this.id, required this.text, required this.at});
+}
+
+const _toastActions = {'join', 'leave', 'kick', 'swap', 'chat'};
+
+String? roomMediaUrl(RoomBroadcast room) {
+  final media = room.media;
+  if (media == null) return null;
+  final url = media['url'];
+  if (url is String && url.isNotEmpty) return url;
+  return null;
+}
+
+class SessionCoordinator {
+  final SfxService sfx;
+  final SyncClient sync = SyncClient();
+  final PlaybackController playback = PlaybackController();
+  final RoomDiff diff = RoomDiff();
+
+  final health =
+      signal(const HealthStatus(HealthSeverity.info, 'idle'));
+  final room = signal<RoomBroadcast?>(null);
+  final feedLog = signal<List<FeedMessage>>([]);
+  final toasts = signal<List<ToastItem>>([]);
+  final reconnecting = signal(false);
+  final kickReason = signal<String?>(null);
+  final starving = signal<String?>(null);
+
+  late final Computed<MemberView?> selfMember = computed(() {
+    final r = room.value;
+    if (r == null || sync.memberId.isEmpty) return null;
+    for (final m in r.members) {
+      if (m.id == sync.memberId) return m;
+    }
+    return null;
+  });
+
+  Timer? _ticker;
+  StreamSubscription? _roomSub;
+  StreamSubscription? _feedSub;
+  StreamSubscription? _kickSub;
+  StreamSubscription? _errSub;
+  StreamSubscription? _statusSub;
+
+  bool _manualClose = false;
+  bool _playerReady = false;
+  bool _warnedIdle = false;
+  bool _wasPlayAllowed = false;
+  bool _lastReady = false;
+  int _mediaId = -1;
+  String? _openUrl;
+  String _wsHost = '';
+  int _wsPort = 0;
+  double _lastPos = 0;
+  double? _pendingSeekTarget;
+  DateTime? _pendingSeekAt;
+  int _seekRetries = 0;
+  DateTime? _lastRoomAt;
+  DateTime _lastInput = DateTime.now().toUtc();
+  int _toastId = 0;
+  ConnectParams? _params;
+  bool _everConnected = false;
+
+  SessionCoordinator({this.sfx = const NoopSfxService()});
+
+  Future<void> initPlayer() async {
+    if (_playerReady) return;
+    try {
+      await playback.init();
+      _playerReady = true;
+    } catch (e, st) {
+      debugPrint('player init failed: $e\n$st');
+      health.value =
+          HealthStatus(HealthSeverity.error, 'player failed to start: $e');
+      rethrow;
+    }
+  }
+
+  void markInput() {
+    _lastInput = DateTime.now().toUtc();
+    _warnedIdle = false;
+  }
+
+  Future<void> connect(ConnectParams params) async {
+    await leave(silent: true);
+    _params = params;
+    _manualClose = false;
+    kickReason.value = null;
+    _wsHost = params.host;
+    _wsPort = params.port;
+    diff.reset();
+    _mediaId = -1;
+    _openUrl = null;
+    _lastReady = false;
+    _wasPlayAllowed = false;
+    _everConnected = false;
+    markInput();
+    _subscribe();
+    feedLog.value = [];
+    toasts.value = [];
+    await initPlayer();
+    health.value =
+        const HealthStatus(HealthSeverity.info, 'connecting…');
+    final wsUri = Uri.parse('ws://${params.host}:${params.port}/sync');
+    try {
+      final welcome = await sync.connect(
+        wsUri: wsUri,
+        secret: params.secret,
+        name: params.name,
+        avatar: params.avatar,
+      );
+      reconnecting.value = false;
+      _everConnected = true;
+      health.value = const HealthStatus(HealthSeverity.ok, 'connected');
+      _lastRoomAt = DateTime.now().toUtc();
+      final url = welcome.mediaUrl;
+      if (url != null && url.isNotEmpty) {
+        await _openMedia(url);
+      } else {
+        health.value = const HealthStatus(
+            HealthSeverity.info, 'connected — waiting for host media…');
+      }
+      if (params.linkUrl.isNotEmpty) {
+        sync.sendSwap(HelloMedia(
+            name: params.linkUrl, size: 0, duration: 0, url: params.linkUrl));
+      }
+      _startTicker();
+    } catch (e) {
+      debugPrint('connect failed: $e');
+      health.value =
+          HealthStatus(HealthSeverity.error, _friendlyError(e));
+      _scheduleReconnect();
+      rethrow;
+    }
+  }
+
+  void _subscribe() {
+    _roomSub ??= sync.rooms.listen(_onRoom);
+    _feedSub ??= sync.feeds.listen(_onFeed);
+    _kickSub ??= sync.kicked.listen(_onKicked);
+    _errSub ??= sync.errors.listen((msg) {
+      health.value = HealthStatus(HealthSeverity.warn, msg);
+    });
+    _statusSub ??= sync.status.listen((s) {
+      if (s == SyncStatus.closed && !_manualClose && kickReason.peek() == null) {
+        health.value = const HealthStatus(
+            HealthSeverity.warn, 'connection lost — retrying…');
+        _scheduleReconnect();
+      }
+    });
+  }
+
+  Future<void> _openMedia(String url) async {
+    if (url == _openUrl) return;
+    _openUrl = url;
+    diff.reset();
+    try {
+      await playback.openUrl(url);
+      health.value =
+          const HealthStatus(HealthSeverity.ok, 'connected');
+    } catch (e) {
+      debugPrint('open media failed: $e');
+      health.value =
+          HealthStatus(HealthSeverity.error, 'cannot open media: $e');
+    }
+  }
+
+  String _fileUrlFor(String name) {
+    return 'http://$_wsHost:$_wsPort/m/default/${sync.token}/${Uri.encodeComponent(name)}';
+  }
+
+  Future<void> _onRoom(RoomBroadcast r) async {
+    final now = DateTime.now().toUtc();
+    _lastRoomAt = now;
+    room.value = r;
+    if (r.mediaId != _mediaId) {
+      _mediaId = r.mediaId;
+      var url = roomMediaUrl(r);
+      if ((url == null || url.isEmpty) && sync.token.isNotEmpty) {
+        final name = (r.media?['name'] as String?) ?? '';
+        if (name.isNotEmpty) url = _fileUrlFor(name);
+      }
+      if (url != null && url.isNotEmpty) {
+        await _openMedia(url);
+      } else {
+        _openUrl = null;
+      }
+      _pendingSeekTarget = null;
+      _seekRetries = 0;
+    }
+    if (!_playerReady || _openUrl == null) {
+      _wasPlayAllowed = false;
+      _updateStarving(r, 0);
+      return;
+    }
+    final allowed = localPlayAllowed(r, sync.memberId);
+    var actions = diff.diff(r, playback.positionSecs, now);
+    if (r.transport == 'playing' && !allowed) {
+      actions = [
+        for (final a in actions) if (a is! TransportAction) a,
+        const TransportAction(false),
+      ];
+    }
+    if (allowed && !_wasPlayAllowed && r.transport == 'playing') {
+      final edge = roomPositionAt(r, now);
+      actions = [
+        for (final a in actions) if (a is! TransportAction) a,
+        SeekAction(edge),
+        const TransportAction(true),
+      ];
+      _pendingSeekTarget = edge;
+      _pendingSeekAt = now;
+    }
+    _wasPlayAllowed = allowed;
+    for (final a in actions) {
+      if (a is SeekAction) {
+        _pendingSeekTarget = a.position;
+        _pendingSeekAt = now;
+      }
+    }
+    await playback.apply(actions);
+    _updateStarving(r, playback.bufferedSecsAhead);
+  }
+
+  void _updateStarving(RoomBroadcast r, double bufferedAhead) {
+    if (r.transport == 'playing') {
+      starving.value = null;
+      return;
+    }
+    for (final m in r.members) {
+      if (m.inSet && m.buffered < RelayConstants.minBufferSecs) {
+        starving.value =
+            'waiting for ${m.name} — ${m.buffered.toStringAsFixed(1)} s buffered';
+        return;
+      }
+    }
+    final self = selfMember.peek();
+    if (self != null && self.ready) {
+      final waiters = r.members
+          .where((m) => m.id != self.id && !m.stale && !(m.inSet && m.ready))
+          .map((m) => m.name)
+          .toList();
+      if (waiters.isNotEmpty) {
+        final readyCount = r.members.where((m) => m.ready).length;
+        starving.value =
+            'waiting for ${waiters.join(', ')} ($readyCount/${r.members.length} ready)';
+        return;
+      }
+    }
+    if (self != null && !self.ready) {
+      starving.value = 'press Space when ready';
+      return;
+    }
+    if (r.members.any((m) => m.inSet)) {
+      starving.value = 'held — waiting for readiness';
+      return;
+    }
+    starving.value = 'held — press Space when ready';
+  }
+
+  void _onFeed(FeedMessage f) {
+    feedLog.value = [...feedLog.peek(), f].length > 100
+        ? [...feedLog.peek(), f].sublist(feedLog.peek().length - 99)
+        : [...feedLog.peek(), f];
+    if (_toastActions.contains(f.action)) {
+      final text = f.action == 'chat'
+          ? '${f.actor}: ${f.reason}'
+          : _feedText(f);
+      _toastId++;
+      toasts.value = [
+        ...toasts.peek(),
+        ToastItem(id: _toastId, text: text, at: DateTime.now().toUtc())
+      ];
+    }
+    final kind = sfxForFeedAction(f.action);
+    if (kind != null) {
+      var readyIndex = 0;
+      if (f.action == 'ready') {
+        readyIndex = room.peek()?.members.where((m) => m.ready).length ?? 0;
+      }
+      unawaited(sfx.play(SfxCue(kind, readyIndex: readyIndex)));
+    }
+  }
+
+  String _feedText(FeedMessage f) {
+    switch (f.action) {
+      case 'join':
+        return '${f.actor} joined';
+      case 'leave':
+        return '${f.actor} left';
+      case 'kick':
+        return '${f.actor} kicked ${f.target ?? ''}';
+      case 'swap':
+        return '${f.actor} changed media';
+      default:
+        return '${f.actor} ${f.action}';
+    }
+  }
+
+  Future<void> _onKicked(String reason) async {
+    kickReason.value = reason;
+    _manualClose = true;
+    reconnecting.value = false;
+    _ticker?.cancel();
+    _ticker = null;
+    try {
+      await playback.apply(const [TransportAction(false)]);
+    } catch (_) {}
+    await sync.disconnect();
+    health.value = HealthStatus(
+        HealthSeverity.error,
+        reason.isEmpty ? 'kicked from room' : 'kicked: $reason');
+  }
+
+  void _startTicker() {
+    _ticker?.cancel();
+    _ticker = Timer.periodic(const Duration(seconds: 1), (_) => _tick());
+  }
+
+  Future<void> _tick() async {
+    final now = DateTime.now().toUtc();
+    toasts.value =
+        toasts.peek().where((t) => now.difference(t.at).inSeconds < 4).toList();
+    final r = room.peek();
+    if (sync.token.isNotEmpty && r != null && _playerReady) {
+      sync.sendReport(
+        position: playback.positionSecs,
+        buffered: playback.bufferedSecsAhead,
+        eventId: r.eventId,
+      );
+      _detectUserSeek(r);
+      _checkSeekLanded(r);
+    }
+    if (!_manualClose &&
+        kickReason.peek() == null &&
+        _lastRoomAt != null &&
+        now.difference(_lastRoomAt!).inSeconds >= 5) {
+      if (room.peek() != null) {
+        room.value = null;
+        starving.value = null;
+        _wasPlayAllowed = false;
+        _mediaId = -1;
+        _pendingSeekTarget = null;
+        _seekRetries = 0;
+        diff.reset();
+      }
+      if (!reconnecting.peek()) {
+        health.value = const HealthStatus(
+            HealthSeverity.warn, 'connection lost — retrying…');
+        _scheduleReconnect();
+      }
+    }
+    final idleSecs = now.difference(_lastInput).inSeconds;
+    if (idleSecs >= 8 * 60 && !_warnedIdle) {
+      _warnedIdle = true;
+      _toastId++;
+      toasts.value = [
+        ...toasts.peek(),
+        ToastItem(
+            id: _toastId,
+            text: 'idle — auto-unready in 2 min unless you press Space',
+            at: now)
+      ];
+      unawaited(sfx.play(const SfxCue(SfxKind.warn)));
+    }
+    if (idleSecs >= 10 * 60) {
+      final self = selfMember.peek();
+      if (self != null && self.ready) {
+        _lastReady = false;
+        sync.sendReady(false, source: 'auto');
+        markInput();
+      }
+    }
+  }
+
+  void _detectUserSeek(RoomBroadcast r) {
+    if (_openUrl == null) {
+      _lastPos = playback.positionSecs;
+      return;
+    }
+    final now = DateTime.now().toUtc();
+    final pos = playback.positionSecs;
+    final jumped = (pos - _lastPos).abs();
+    _lastPos = pos;
+    if (jumped <= 2.0) return;
+    if ((pos - roomPositionAt(r, now)).abs() < 2.0) return;
+    final recentSync = _pendingSeekAt != null &&
+        now.difference(_pendingSeekAt!).inMilliseconds < 1000;
+    if (recentSync) return;
+    markInput();
+    sync.sendSeek(pos);
+  }
+
+  Future<void> _checkSeekLanded(RoomBroadcast r) async {
+    final target = _pendingSeekTarget;
+    final at = _pendingSeekAt;
+    if (target == null || at == null) return;
+    if (DateTime.now().toUtc().difference(at).inMilliseconds < 1500) return;
+    if (seekLanded(ownPosition: playback.positionSecs, target: target)) {
+      _pendingSeekTarget = null;
+      _pendingSeekAt = null;
+      _seekRetries = 0;
+      return;
+    }
+    if (_seekRetries < 1) {
+      _seekRetries++;
+      _pendingSeekAt = DateTime.now().toUtc();
+      await playback.apply([SeekAction(target)]);
+    } else {
+      _pendingSeekTarget = null;
+      _pendingSeekAt = null;
+      _seekRetries = 0;
+    }
+  }
+
+  void toggleReady() {
+    final self = selfMember.peek();
+    final next = !(self?.ready ?? false);
+    markInput();
+    _lastReady = next;
+    sync.sendReady(next, source: 'manual');
+  }
+
+  void forceTarget(String memberId, bool ready) {
+    markInput();
+    sync.sendForce(memberId, ready);
+  }
+
+  void forcePlayAll() {
+    markInput();
+    sync.sendForce('all', true);
+  }
+
+  void seekTo(double position) {
+    markInput();
+    sync.sendSeek(position);
+  }
+
+  void nudge(double deltaSecs) {
+    final r = room.peek();
+    if (r == null || _openUrl == null) return;
+    final target =
+        roomPositionAt(r, DateTime.now().toUtc()) + deltaSecs;
+    if (target.isNaN || target < 0) return;
+    markInput();
+    sync.sendSeek(target);
+  }
+
+  void sendChat(String text) {
+    markInput();
+    sync.sendChat(text);
+  }
+
+  void kick(String memberId, {String reason = ''}) {
+    markInput();
+    sync.sendKick(memberId, reason: reason);
+  }
+
+  Future<void> swapLink(String url) async {
+    markInput();
+    sync.sendSwap(
+        HelloMedia(name: url, size: 0, duration: 0, url: url));
+  }
+
+  void _scheduleReconnect({bool manual = false}) {
+    if (_manualClose || kickReason.peek() != null || _params == null) return;
+    if (!manual && !_everConnected) return;
+    if (reconnecting.peek()) return;
+    reconnecting.value = true;
+    Future.delayed(const Duration(milliseconds: 1500), () async {
+      if (_manualClose || kickReason.peek() != null) {
+        reconnecting.value = false;
+        return;
+      }
+      final params = _params;
+      if (params == null) {
+        reconnecting.value = false;
+        return;
+      }
+      try {
+        health.value = const HealthStatus(
+            HealthSeverity.info, 'reconnecting…');
+        final wsUri = Uri.parse('ws://${params.host}:${params.port}/sync');
+        final welcome = await sync.connect(
+          wsUri: wsUri,
+          secret: params.secret,
+          name: params.name,
+          avatar: params.avatar,
+        );
+        reconnecting.value = false;
+        _everConnected = true;
+        health.value = const HealthStatus(HealthSeverity.ok, 'connected');
+        final url = welcome.mediaUrl;
+        if (url != null && url.isNotEmpty && url != _openUrl) {
+          await _openMedia(url);
+        }
+        if (_lastReady) sync.sendReady(true, source: 'manual');
+        _startTicker();
+      } catch (e) {
+        debugPrint('reconnect failed: $e');
+        reconnecting.value = false;
+        _scheduleReconnect();
+      }
+    });
+  }
+
+  void cancelReconnect() {
+    _manualClose = true;
+    reconnecting.value = false;
+  }
+
+  Future<void> cancelConnect() async {
+    _manualClose = true;
+    reconnecting.value = false;
+    try {
+      await sync.disconnect();
+    } catch (_) {}
+    health.value = const HealthStatus(HealthSeverity.info, 'cancelled');
+  }
+
+  void retry() {
+    if (kickReason.peek() != null || _params == null) return;
+    _manualClose = false;
+    reconnecting.value = false;
+    health.value =
+        const HealthStatus(HealthSeverity.info, 'retrying…');
+    _scheduleReconnect(manual: true);
+  }
+
+  String _friendlyError(Object e) {
+    final msg = '$e';
+    if (msg.contains('proto mismatch')) return 'host runs a different version — update the app';
+    if (msg.contains('wrong secret')) return 'wrong room password (401)';
+    if (msg.contains('SocketException') || msg.contains('Connection refused')) {
+      return 'host offline — check address and port';
+    }
+    return 'connect failed: $e';
+  }
+
+  Future<void> leave({bool silent = false}) async {
+    _manualClose = true;
+    _ticker?.cancel();
+    _ticker = null;
+    reconnecting.value = false;
+    try {
+      await playback.stop();
+    } catch (_) {}
+    try {
+      await sync.disconnect();
+    } catch (_) {}
+    if (!silent) {
+      room.value = null;
+      starving.value = null;
+      health.value = const HealthStatus(HealthSeverity.info, 'idle');
+    }
+  }
+
+  Future<void> dispose() async {
+    await leave(silent: true);
+    await _roomSub?.cancel();
+    await _feedSub?.cancel();
+    await _kickSub?.cancel();
+    await _errSub?.cancel();
+    await _statusSub?.cancel();
+    await sync.dispose();
+    await playback.dispose();
+  }
+}

apps/desktop/lib/src/sfx/sfx.dart

@@ -0,0 +1,72 @@
+enum SfxKind {
+  ready,
+  unready,
+  forceReady,
+  forceUnready,
+  forcePlay,
+  forceHold,
+  kick,
+  join,
+  leave,
+  stale,
+  swap,
+  seek,
+  pause,
+  resume,
+  chat,
+  warn,
+}
+
+class SfxCue {
+  final SfxKind kind;
+  final int readyIndex;
+  const SfxCue(this.kind, {this.readyIndex = 0});
+}
+
+SfxKind? sfxForFeedAction(String action) {
+  switch (action) {
+    case 'ready':
+      return SfxKind.ready;
+    case 'unready':
+      return SfxKind.unready;
+    case 'force-ready':
+      return SfxKind.forceReady;
+    case 'force-unready':
+      return SfxKind.forceUnready;
+    case 'force-play':
+      return SfxKind.forcePlay;
+    case 'force-hold':
+      return SfxKind.forceHold;
+    case 'kick':
+      return SfxKind.kick;
+    case 'join':
+      return SfxKind.join;
+    case 'leave':
+      return SfxKind.leave;
+    case 'stale':
+      return SfxKind.stale;
+    case 'swap':
+      return SfxKind.swap;
+    case 'seek':
+      return SfxKind.seek;
+    case 'pause':
+      return SfxKind.pause;
+    case 'resume':
+      return SfxKind.resume;
+    case 'chat':
+      return SfxKind.chat;
+    default:
+      return null;
+  }
+}
+
+abstract class SfxService {
+  Future<void> play(SfxCue cue);
+}
+
+class NoopSfxService implements SfxService {
+  const NoopSfxService();
+
+  @override
+  Future<void> play(SfxCue cue) async {}
+}

apps/desktop/lib/src/state/connect_prefs.dart

@@ -0,0 +1,21 @@
+import 'package:hive_ce/hive.dart';
+
+const connectFormBoxName = 'connect_form';
+
+const connectKeyHost = 'host';
+const connectKeyPort = 'port';
+const connectKeySecret = 'secret';
+const connectKeyName = 'name';
+const connectKeyAvatarPath = 'avatarPath';
+const connectKeyMediaPath = 'mediaPath';
+const connectKeyLinkUrl = 'linkUrl';
+
+Future<Box> openConnectFormBox() => Hive.openBox(connectFormBoxName);
+
+Box? connectFormBoxIfOpen() =>
+    Hive.isBoxOpen(connectFormBoxName) ? Hive.box(connectFormBoxName) : null;
+
+String readString(Box box, String key, String fallback) {
+  final v = box.get(key);
+  return v is String ? v : fallback;
+}

apps/desktop/lib/src/state/session_state.dart

@@ -0,0 +1,159 @@
+import 'package:flutter/widgets.dart';
+import 'package:signals/signals_flutter.dart';
+import 'package:sync_relay_core/core.dart';
+import 'package:sync_relay_server/server.dart';
+
+import '../sfx/sfx.dart';
+import '../session/health.dart';
+import '../session/session_coordinator.dart';
+import '../widgets/avatar_pipeline.dart';
+import 'connect_prefs.dart';
+
+enum AppRoute { welcome, connect, session }
+
+enum ConnectMode { host, join }
+
+class ConnectForm {
+  String host;
+  String port;
+  String secret;
+  String name;
+  String avatarPath;
+  String mediaPath;
+  String linkUrl;
+  ConnectForm({
+    this.host = '127.0.0.1',
+    this.port = '8080',
+    this.secret = '',
+    this.name = '',
+    this.avatarPath = '',
+    this.mediaPath = '',
+    this.linkUrl = '',
+  });
+}
+
+class SessionState {
+  static final SessionState instance = SessionState._();
+  SessionState._();
+
+  final route = signal(AppRoute.welcome);
+  final connectMode = signal(ConnectMode.host);
+  final status = signal(const HealthStatus(HealthSeverity.info, 'idle'));
+  final room = signal<RoomBroadcast?>(null);
+  final SfxService sfx = const NoopSfxService();
+  late final SessionCoordinator coordinator = SessionCoordinator(sfx: sfx);
+  final lastForm = ConnectForm();
+  RoomServer? _server;
+
+  Future<void> loadForm() async {
+    final box = await openConnectFormBox();
+    lastForm
+      ..host = readString(box, connectKeyHost, '127.0.0.1')
+      ..port = readString(box, connectKeyPort, '8080')
+      ..secret = readString(box, connectKeySecret, '')
+      ..name = readString(box, connectKeyName, '')
+      ..avatarPath = readString(box, connectKeyAvatarPath, '')
+      ..mediaPath = readString(box, connectKeyMediaPath, '')
+      ..linkUrl = readString(box, connectKeyLinkUrl, '');
+  }
+
+  Future<void> saveForm() async {
+    final box = connectFormBoxIfOpen() ?? await openConnectFormBox();
+    await box.putAll({
+      connectKeyHost: lastForm.host,
+      connectKeyPort: lastForm.port,
+      connectKeySecret: lastForm.secret,
+      connectKeyName: lastForm.name,
+      connectKeyAvatarPath: lastForm.avatarPath,
+      connectKeyMediaPath: lastForm.mediaPath,
+      connectKeyLinkUrl: lastForm.linkUrl,
+    });
+  }
+
+  Future<String> loadAvatar(String path) => encodeAvatar(path);
+
+  void goConnect(ConnectMode mode) {
+    connectMode.value = mode;
+    route.value = AppRoute.connect;
+  }
+
+  Future<void> host(ConnectParams params, ConnectForm form) async {
+    _rememberForm(form);
+    status.value = const HealthStatus(HealthSeverity.info, 'starting server…');
+    await stopServer();
+    final server = RoomServer(AppConfig(
+      port: params.port,
+      secret: params.secret,
+      name: 'room',
+      mediaPath: params.mediaPath,
+    ));
+    try {
+      await server.start();
+    } catch (e, st) {
+      debugPrint('server start failed: $e\n$st');
+      status.value =
+          HealthStatus(HealthSeverity.error, 'cannot bind port ${params.port}: $e');
+      rethrow;
+    }
+    _server = server;
+    status.value =
+        HealthStatus(HealthSeverity.ok, 'hosting on port ${server.boundPort}');
+    await coordinator.connect(ConnectParams(
+      host: '127.0.0.1',
+      port: server.boundPort,
+      secret: params.secret,
+      name: params.name,
+      avatar: params.avatar,
+      linkUrl: params.linkUrl,
+    ));
+    route.value = AppRoute.session;
+    try {
+      await saveForm();
+    } catch (e, st) {
+      debugPrint('save connect form failed: $e\n$st');
+    }
+  }
+
+  Future<void> join(ConnectParams params, ConnectForm form) async {
+    _rememberForm(form);
+    await coordinator.connect(params);
+    route.value = AppRoute.session;
+    try {
+      await saveForm();
+    } catch (e, st) {
+      debugPrint('save connect form failed: $e\n$st');
+    }
+  }
+
+  void _rememberForm(ConnectForm form) {
+    lastForm
+      ..host = form.host
+      ..port = form.port
+      ..secret = form.secret
+      ..name = form.name
+      ..avatarPath = form.avatarPath
+      ..mediaPath = form.mediaPath
+      ..linkUrl = form.linkUrl;
+  }
+
+  Future<void> startHeadless(List<String> args) async {
+    int port = 8080;
+    for (var i = 0; i < args.length - 1; i++) {
+      if (args[i] == '--port') port = int.tryParse(args[i + 1]) ?? port;
+    }
+    _server = RoomServer(AppConfig(port: port, secret: 'change-me', name: 'room'));
+    await _server!.start();
+  }
+
+  Future<void> stopServer() async {
+    await _server?.stop();
+    _server = null;
+  }
+
+  Future<void> leave() async {
+    await coordinator.leave();
+    await stopServer();
+    status.value = const HealthStatus(HealthSeverity.info, 'idle');
+    route.value = AppRoute.connect;
+  }
+}

apps/desktop/lib/src/sync/room_diff.dart

@@ -0,0 +1,142 @@
+import 'package:sync_relay_core/core.dart';
+
+sealed class PlayerAction {
+  const PlayerAction();
+}
+
+class SeekAction extends PlayerAction {
+  final double position;
+  const SeekAction(this.position);
+}
+
+class TransportAction extends PlayerAction {
+  final bool playing;
+  const TransportAction(this.playing);
+}
+
+class RateAction extends PlayerAction {
+  final double rate;
+  const RateAction(this.rate);
+}
+
+double roomPositionAt(RoomBroadcast room, DateTime now) {
+  if (room.transport != 'playing') return room.position;
+  return room.position + now.difference(room.serverTime).inMilliseconds / 1000.0;
+}
+
+bool seekLanded({required double ownPosition, required double target}) {
+  if ((ownPosition - target).abs() > RelayConstants.driftSeekThresholdSecs) {
+    return false;
+  }
+  return true;
+}
+
+bool localPlayAllowed(RoomBroadcast room, String memberId) {
+  if (memberId.isEmpty) return false;
+  for (final m in room.members) {
+    if (m.id == memberId) return m.inSet && m.ready;
+  }
+  return false;
+}
+
+class RoomDiff {
+  static const debounceWindow = Duration(seconds: 2);
+
+  int _lastEventId = -1;
+  String _lastTransport = '';
+  int _lastMediaId = -1;
+  bool _slowing = false;
+  DateTime? _deviatingSince;
+  int _deviatingEvent = -1;
+
+  bool get slowing => _slowing;
+
+  List<PlayerAction> diff(RoomBroadcast room, double ownPosition, DateTime now) {
+    final out = <PlayerAction>[];
+    final roomPos = roomPositionAt(room, now);
+
+    if (room.mediaId != _lastMediaId && _lastMediaId != -1) {
+      _lastEventId = room.eventId;
+      _lastTransport = room.transport;
+      _lastMediaId = room.mediaId;
+      _slowing = false;
+      _deviatingSince = null;
+      out.add(const SeekAction(0));
+      out.add(const TransportAction(false));
+      out.add(const RateAction(1.0));
+      return out;
+    }
+
+    if (_lastEventId == -1) {
+      _lastEventId = room.eventId;
+      _lastTransport = room.transport;
+      _lastMediaId = room.mediaId;
+      _deviatingSince = null;
+      out.add(SeekAction(roomPos));
+      out.add(TransportAction(room.transport == 'playing'));
+      return out;
+    }
+
+    if (room.eventId != _lastEventId) {
+      _lastEventId = room.eventId;
+      _slowing = false;
+      _deviatingSince = null;
+      out.add(const RateAction(1.0));
+      out.add(SeekAction(roomPos));
+      if (room.transport != _lastTransport) {
+        _lastTransport = room.transport;
+        out.add(TransportAction(room.transport == 'playing'));
+      }
+      return out;
+    }
+
+    if (room.transport != _lastTransport) {
+      _lastTransport = room.transport;
+      _slowing = false;
+      _deviatingSince = null;
+      out.add(const RateAction(1.0));
+      out.add(TransportAction(room.transport == 'playing'));
+      out.add(SeekAction(roomPos));
+      return out;
+    }
+
+    final drift = ownPosition - roomPos;
+    if (_slowing) {
+      if (drift.abs() < 0.1) {
+        _slowing = false;
+        out.add(const RateAction(1.0));
+      }
+      return out;
+    }
+    switch (correctionFor(ownPosition: ownPosition, roomPosition: roomPos)) {
+      case Correction.seek:
+        if (_deviatingEvent != room.eventId || _deviatingSince == null) {
+          _deviatingEvent = room.eventId;
+          _deviatingSince = now;
+          break;
+        }
+        if (now.difference(_deviatingSince!).compareTo(debounceWindow) < 0) {
+          break;
+        }
+        _deviatingSince = null;
+        out.add(SeekAction(roomPos));
+      case Correction.slowDown:
+        _deviatingSince = null;
+        _slowing = true;
+        out.add(const RateAction(RelayConstants.slowDownRate));
+      case Correction.none:
+        _deviatingSince = null;
+        break;
+    }
+    return out;
+  }
+
+  void reset() {
+    _lastEventId = -1;
+    _lastTransport = '';
+    _lastMediaId = -1;
+    _slowing = false;
+    _deviatingSince = null;
+    _deviatingEvent = -1;
+  }
+}

apps/desktop/lib/src/sync/sync_client.dart

@@ -0,0 +1,228 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:sync_relay_core/core.dart';
+import 'package:web_socket_channel/web_socket_channel.dart';
+
+enum SyncStatus { idle, connecting, open, kicked, closed, error }
+
+class SyncClient {
+  WebSocketChannel? _channel;
+  StreamSubscription? _sub;
+  final StreamController<RoomBroadcast> _rooms = StreamController.broadcast();
+  final StreamController<FeedMessage> _feeds = StreamController.broadcast();
+  final StreamController<String> _kicked = StreamController.broadcast();
+  final StreamController<String> _errors = StreamController.broadcast();
+  final StreamController<SyncStatus> _status = StreamController.broadcast();
+
+  Stream<RoomBroadcast> get rooms => _rooms.stream;
+  Stream<FeedMessage> get feeds => _feeds.stream;
+  Stream<String> get kicked => _kicked.stream;
+  Stream<String> get errors => _errors.stream;
+  Stream<SyncStatus> get status => _status.stream;
+
+  String token = '';
+  String memberId = '';
+  String? mediaUrl;
+  RoomBroadcast? lastRoom;
+  Completer<WelcomeMessage>? _pendingWelcome;
+
+  Future<WelcomeMessage> connect({
+    required Uri wsUri,
+    required String secret,
+    required String name,
+    String avatar = '',
+    HelloMedia? media,
+  }) async {
+    await disconnect();
+    _status.add(SyncStatus.connecting);
+    final ch = WebSocketChannel.connect(wsUri);
+    unawaited(ch.ready.then((_) {}, onError: (_) {}));
+    _channel = ch;
+    final welcomeCompleter = Completer<WelcomeMessage>();
+    _sub = ch.stream.listen(
+      (raw) => _onText('$raw', welcomeCompleter),
+      onError: (Object e, StackTrace st) {
+        if (!welcomeCompleter.isCompleted) {
+          welcomeCompleter.completeError(e, st);
+        }
+        _status.add(SyncStatus.error);
+      },
+      onDone: () {
+        if (!welcomeCompleter.isCompleted) {
+          welcomeCompleter.completeError(StateError('closed before welcome'));
+        }
+        _status.add(SyncStatus.closed);
+      },
+      cancelOnError: false,
+    );
+    final hello = HelloMessage(
+      proto: RelayConstants.protoVersion,
+      secret: secret,
+      user: HelloUser(name: name, avatar: avatar),
+      media: media ?? const HelloMedia(name: '', size: 0, duration: 0),
+    );
+    ch.sink.add(jsonEncode(hello.toJson()));
+    _pendingWelcome = welcomeCompleter;
+    try {
+      final welcome = await welcomeCompleter.future.timeout(
+        const Duration(seconds: 10),
+      );
+      _pendingWelcome = null;
+      token = welcome.token;
+      memberId = welcome.memberId;
+      mediaUrl = welcome.mediaUrl;
+      if (welcome.state != null) {
+        try {
+          lastRoom = RoomBroadcast.fromJson(welcome.state!);
+          _rooms.add(lastRoom!);
+        } catch (_) {}
+      }
+      _status.add(SyncStatus.open);
+      return welcome;
+    } catch (e) {
+      _pendingWelcome = null;
+      await disconnect();
+      _status.add(SyncStatus.error);
+      rethrow;
+    }
+  }
+
+  void _onText(String raw, Completer<WelcomeMessage> welcomeCompleter) {
+    Map<String, Object?> decoded;
+    try {
+      final parsed = jsonDecode(raw);
+      if (parsed is! Map) return;
+      decoded = Map<String, Object?>.from(parsed);
+    } catch (_) {
+      return;
+    }
+    final t = decoded['t'];
+    if (!welcomeCompleter.isCompleted) {
+      if (t == 'welcome') {
+        try {
+          welcomeCompleter.complete(WelcomeMessage.fromJson(decoded));
+        } catch (e) {
+          welcomeCompleter.completeError(e);
+        }
+      } else if (t == 'err') {
+        welcomeCompleter.completeError(
+          ProtocolException('${decoded['message'] ?? 'rejected'}'),
+        );
+      }
+      return;
+    }
+    switch (t) {
+      case 'room':
+        try {
+          final room = RoomBroadcast.fromJson(decoded);
+          lastRoom = room;
+          _rooms.add(room);
+        } catch (_) {}
+      case 'feed':
+        try {
+          _feeds.add(FeedMessage.fromJson(decoded));
+        } catch (_) {}
+      case 'kicked':
+        try {
+          final msg = KickedMessage.fromJson(decoded);
+          _kicked.add(msg.reason);
+          _status.add(SyncStatus.kicked);
+        } catch (_) {
+          _kicked.add('');
+        }
+      case 'err':
+        _errors.add('${decoded['message'] ?? 'error'}');
+      case 'chat':
+        try {
+          _feeds.add(
+            FeedMessage(
+              actor: '${decoded['from'] ?? '?'}',
+              action: 'chat',
+              reason: (decoded['text'] as String?) ?? '',
+              at: DateTime.now().toUtc(),
+            ),
+          );
+        } catch (_) {}
+    }
+  }
+
+  void _send(Map<String, Object?> json) {
+    final ch = _channel;
+    if (ch == null) return;
+    try {
+      ch.sink.add(jsonEncode(json));
+    } catch (_) {}
+  }
+
+  void sendReady(bool ready, {String source = 'manual'}) {
+    _send(ReadyIntent(ready: ready, source: source).toJson());
+  }
+
+  void sendForce(String target, bool ready) {
+    _send(ForceIntent(target: target, ready: ready).toJson());
+  }
+
+  void sendSeek(double position) {
+    if (position.isNaN || position < 0) return;
+    _send(SeekIntent(position: position).toJson());
+  }
+
+  void sendSwap(HelloMedia media) {
+    _send(SwapIntent(media: media).toJson());
+  }
+
+  void sendReport({
+    required double position,
+    required double buffered,
+    required int eventId,
+  }) {
+    final safeBuffered = buffered.isNaN || buffered < 0 ? 0.0 : buffered;
+    _send(
+      ReportMessage(
+        position: position,
+        buffered: safeBuffered,
+        eventId: eventId,
+      ).toJson(),
+    );
+  }
+
+  void sendChat(String text) {
+    final clean = text.length > RelayConstants.maxChatLength
+        ? text.substring(0, RelayConstants.maxChatLength)
+        : text;
+    _send(ChatMessage(text: clean).toJson());
+  }
+
+  void sendKick(String target, {String reason = ''}) {
+    _send(KickRequest(target: target, reason: reason).toJson());
+  }
+
+  Future<void> disconnect() async {
+    final pending = _pendingWelcome;
+    _pendingWelcome = null;
+    if (pending != null && !pending.isCompleted) {
+      pending.completeError(StateError('cancelled'));
+    }    try {
+      await _sub?.cancel();
+    } catch (_) {}
+    _sub = null;
+    try {
+      await _channel?.sink.close();
+    } catch (_) {}
+    _channel = null;
+    token = '';
+    memberId = '';
+    mediaUrl = null;
+    lastRoom = null;
+  }
+
+  Future<void> dispose() async {
+    await disconnect();
+    await _rooms.close();
+    await _feeds.close();
+    await _kicked.close();
+    await _errors.close();
+    await _status.close();
+  }
+}

apps/desktop/lib/src/widgets/avatar_pipeline.dart

@@ -0,0 +1,44 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:image/image.dart' as img;
+
+Future<String> encodeAvatar(String path) async {
+  final trimmed = path.trim();
+  if (trimmed.isEmpty) return '';
+  final file = File(trimmed);
+  if (!await file.exists()) {
+    throw const FormatException(
+        'avatar file not found — check the path or pick again with Browse');
+  }
+  late final List<int> raw;
+  try {
+    raw = await file.readAsBytes();
+  } catch (_) {
+    throw const FormatException(
+        'could not read that avatar file — pick it again with Browse');
+  }
+  if (raw.isEmpty) {
+    throw const FormatException(
+        'that avatar file is empty — pick a PNG, JPG or WebP photo');
+  }
+  final decoded = img.decodeImage(Uint8List.fromList(raw));
+  if (decoded == null) {
+    throw const FormatException(
+        'could not read that image — pick a PNG, JPG or WebP photo');
+  }
+  final side =
+      decoded.width < decoded.height ? decoded.width : decoded.height;
+  final x = (decoded.width - side) ~/ 2;
+  final y = (decoded.height - side) ~/ 2;
+  final cropped =
+      img.copyCrop(decoded, x: x, y: y, width: side, height: side);
+  final resized = img.copyResize(cropped, width: 128, height: 128);
+  final jpg = img.encodeJpg(resized, quality: 85);
+  if (jpg.length > 64 * 1024) {
+    throw const FormatException(
+        'that photo is still too large after shrinking — pick a smaller one');
+  }
+  return base64Encode(jpg);
+}

apps/desktop/lib/src/widgets/dialogs.dart

@@ -0,0 +1,22 @@
+import 'package:flutter/material.dart';
+
+Future<bool?> showKickConfirmDialog(
+    BuildContext context, String memberName) {
+  return showDialog<bool>(
+    context: context,
+    builder: (context) => AlertDialog(
+      title: Text('Remove $memberName?'),
+      content: const Text('They can come straight back in.'),
+      actions: [
+        TextButton(
+          onPressed: () => Navigator.pop(context, false),
+          child: const Text('Cancel'),
+        ),
+        TextButton(
+          onPressed: () => Navigator.pop(context, true),
+          child: const Text('Remove'),
+        ),
+      ],
+    ),
+  );
+}

apps/desktop/lib/src/widgets/media_input.dart

@@ -0,0 +1,8 @@
+({String mediaPath, String linkUrl}) parseMediaInput(String input) {
+  final trimmed = input.trim();
+  final lower = trimmed.toLowerCase();
+  if (lower.startsWith('http://') || lower.startsWith('https://')) {
+    return (mediaPath: '', linkUrl: trimmed);
+  }
+  return (mediaPath: trimmed, linkUrl: '');
+}

apps/desktop/lib/src/widgets/member_avatar.dart

@@ -0,0 +1,65 @@
+import 'dart:convert';
+
+import 'package:flutter/material.dart';
+
+class MemberAvatar extends StatelessWidget {
+  final String avatarBase64;
+  final String name;
+  final double size;
+
+  static final Map<String, MemoryImage> _images = {};
+
+  const MemberAvatar({
+    super.key,
+    required this.avatarBase64,
+    required this.name,
+    this.size = 40,
+  });
+
+  static MemoryImage? _providerFor(String raw) {
+    if (raw.isEmpty) return null;
+    var hit = _images[raw];
+    if (hit != null) return hit;
+    try {
+      hit = MemoryImage(base64Decode(raw));
+    } catch (_) {
+      return null;
+    }
+    if (_images.length > 64) _images.clear();
+    _images[raw] = hit;
+    return hit;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final image = _providerFor(avatarBase64);
+    final decoration = BoxDecoration(
+      shape: BoxShape.circle,
+    );
+    if (image != null) {
+      return Container(
+        decoration: decoration,
+        child: ClipOval(
+          child: Image(
+            image: ResizeImage(height: (size * MediaQuery.of(context).devicePixelRatio).round(), image),
+            width: size,
+            height: size,
+            fit: BoxFit.cover,
+            gaplessPlayback: true,
+            errorBuilder: (_, __, ___) => _fallback(),
+          ),
+        ),
+      );
+    }
+    return Container(decoration: decoration, child: _fallback());
+  }
+
+  Widget _fallback() => CircleAvatar(
+        radius: size / 2,
+        backgroundColor: Colors.grey.shade800,
+        child: Text(
+          name.isEmpty ? '?' : name[0].toUpperCase(),
+          style: TextStyle(fontSize: size * 0.4, color: Colors.white),
+        ),
+      );
+}

apps/desktop/lib/src/widgets/user_section.dart

@@ -0,0 +1,163 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+import 'package:file_picker/file_picker.dart';
+import 'package:flutter/material.dart';
+
+import '../state/session_state.dart';
+import 'avatar_pipeline.dart';
+
+/// Profile card for the connect screen.
+///
+/// Lives in a fixed corner card outside the scrolling form, so Host/Join
+/// field changes below never move it. Name edits write back to
+/// [SessionState.lastForm] on every change (persisted on submit); avatar
+/// changes by tapping the circle, validated through [encodeAvatar] before
+/// the path is stored, with the encoded bytes shown as the preview.
+class ConnectProfileCard extends StatefulWidget {
+  final TextEditingController name;
+  const ConnectProfileCard({super.key, required this.name});
+
+  @override
+  State<ConnectProfileCard> createState() => _ConnectProfileCardState();
+}
+
+class _ConnectProfileCardState extends State<ConnectProfileCard> {
+  late String _avatarPath;
+  Uint8List? _preview;
+  String? _error;
+  bool _picking = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _avatarPath = SessionState.instance.lastForm.avatarPath;
+    _refreshPreview();
+  }
+
+  Future<void> _refreshPreview() async {
+    String b64;
+    try {
+      b64 = await encodeAvatar(_avatarPath);
+    } catch (_) {
+      return;
+    }
+    if (!mounted) return;
+    setState(() => _preview = b64.isEmpty ? null : base64Decode(b64));
+  }
+
+  Future<void> _persistProfile() async {
+    try {
+      await SessionState.instance.saveForm();
+    } catch (_) {
+      if (!mounted) return;
+      setState(() => _error = 'could not save profile — try again');
+    }
+  }
+
+  Future<void> _pickAvatar() async {
+    if (_picking) return;
+    setState(() {
+      _picking = true;
+      _error = null;
+    });
+    try {
+      final List<PlatformFile> files;
+      try {
+        files = await FilePicker.pickFiles(
+          dialogTitle: 'Pick avatar image',
+          type: FileType.custom,
+          allowedExtensions: const ['png', 'jpg', 'jpeg', 'webp'],
+        );
+      } catch (_) {
+        if (!mounted) return;
+        setState(() => _error = 'file dialog unavailable — try again');
+        return;
+      }
+      if (files.isEmpty) return;
+      final path = files.first.path;
+      if (path == null || !mounted) return;
+      late final String b64;
+      try {
+        b64 = await encodeAvatar(path);
+      } on FormatException catch (e) {
+        if (!mounted) return;
+        setState(() => _error = e.message);
+        return;
+      } catch (_) {
+        if (!mounted) return;
+        setState(() => _error =
+            'could not read that image — pick a PNG, JPG or WebP photo');
+        return;
+      }
+      _avatarPath = path;
+      SessionState.instance.lastForm.avatarPath = path;
+      await _persistProfile();
+      if (!mounted) return;
+      setState(() => _preview = b64.isEmpty ? null : base64Decode(b64));
+    } finally {
+      if (mounted) setState(() => _picking = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        GestureDetector(
+          onTap: _pickAvatar,
+          child: Tooltip(
+            message: 'Change avatar',
+            child: CircleAvatar(
+              radius: 22,
+              backgroundColor: Colors.grey.shade800,
+              backgroundImage: _preview != null ? MemoryImage(_preview!) : null,
+              child: _preview != null
+                  ? null
+                  : _picking
+                      ? const SizedBox(
+                          width: 20,
+                          height: 20,
+                          child: CircularProgressIndicator(strokeWidth: 2),
+                        )
+                      : ListenableBuilder(
+                          listenable: widget.name,
+                          builder: (context, _) {
+                            final t = widget.name.text.trim();
+                            return Text(t.isEmpty ? '?' : t[0].toUpperCase());
+                          },
+                        ),
+            ),
+          ),
+        ),
+        const SizedBox(width: 12),
+        SizedBox(
+          width: 180,
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              TextField(
+                controller: widget.name,
+                decoration: const InputDecoration(
+                  labelText: 'Display name',
+                  isDense: true,
+                ),
+                onChanged: (_) {
+                  SessionState.instance.lastForm.name = widget.name.text.trim();
+                },
+                onSubmitted: (_) => _persistProfile(),
+              ),
+              if (_error != null)
+                Padding(
+                  padding: const EdgeInsets.only(top: 4),
+                  child: Text(_error!, style: const TextStyle(fontSize: 11)),
+                ),
+            ],
+          ),
+        ),
+      ],
+    );
+  }
+}

apps/desktop/linux/.gitignore

@@ -0,0 +1 @@
+flutter/ephemeral

apps/desktop/linux/CMakeLists.txt

@@ -0,0 +1,128 @@
+# Project-level configuration.
+cmake_minimum_required(VERSION 3.13)
+project(runner LANGUAGES CXX)
+
+# The name of the executable created for the application. Change this to change
+# the on-disk name of your application.
+set(BINARY_NAME "watch_together")
+# The unique GTK application identifier for this application. See:
+# https://wiki.gnome.org/HowDoI/ChooseApplicationID
+set(APPLICATION_ID "com.example.watch_together")
+
+# Explicitly opt in to modern CMake behaviors to avoid warnings with recent
+# versions of CMake.
+cmake_policy(SET CMP0063 NEW)
+
+# Load bundled libraries from the lib/ directory relative to the binary.
+set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
+
+# Root filesystem for cross-building.
+if(FLUTTER_TARGET_PLATFORM_SYSROOT)
+  set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT})
+  set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+endif()
+
+# Define build configuration options.
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE "Debug" CACHE
+    STRING "Flutter build mode" FORCE)
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+    "Debug" "Profile" "Release")
+endif()
+
+# Compilation settings that should be applied to most targets.
+#
+# Be cautious about adding new options here, as plugins use this function by
+# default. In most cases, you should add new options to specific targets instead
+# of modifying this function.
+function(APPLY_STANDARD_SETTINGS TARGET)
+  target_compile_features(${TARGET} PUBLIC cxx_std_14)
+  target_compile_options(${TARGET} PRIVATE -Wall -Werror)
+  target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
+  target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
+endfunction()
+
+# Flutter library and tool build rules.
+set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
+add_subdirectory(${FLUTTER_MANAGED_DIR})
+
+# System-level dependencies.
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
+
+# Application build; see runner/CMakeLists.txt.
+add_subdirectory("runner")
+
+# Run the Flutter tool portions of the build. This must not be removed.
+add_dependencies(${BINARY_NAME} flutter_assemble)
+
+# Only the install-generated bundle's copy of the executable will launch
+# correctly, since the resources must in the right relative locations. To avoid
+# people trying to run the unbundled copy, put it in a subdirectory instead of
+# the default top-level location.
+set_target_properties(${BINARY_NAME}
+  PROPERTIES
+  RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
+)
+
+
+# Generated plugin build rules, which manage building the plugins and adding
+# them to the application.
+include(flutter/generated_plugins.cmake)
+
+
+# === Installation ===
+# By default, "installing" just makes a relocatable bundle in the build
+# directory.
+set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+  set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
+endif()
+
+# Start with a clean build bundle directory every time.
+install(CODE "
+  file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
+  " COMPONENT Runtime)
+
+set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
+set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")
+
+install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
+  COMPONENT Runtime)
+
+install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
+  COMPONENT Runtime)
+
+install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+  COMPONENT Runtime)
+
+foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES})
+  install(FILES "${bundled_library}"
+    DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+    COMPONENT Runtime)
+endforeach(bundled_library)
+
+# Copy the native assets provided by the build.dart from all packages.
+set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/")
+install(DIRECTORY "${NATIVE_ASSETS_DIR}"
+   DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+   COMPONENT Runtime)
+
+# Fully re-copy the assets directory on each build to avoid having stale files
+# from a previous install.
+set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
+install(CODE "
+  file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
+  " COMPONENT Runtime)
+install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
+  DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
+
+# Install the AOT library on non-Debug builds only.
+if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
+  install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+    COMPONENT Runtime)
+endif()

apps/desktop/linux/flutter/CMakeLists.txt

@@ -0,0 +1,88 @@
+# This file controls Flutter-level build steps. It should not be edited.
+cmake_minimum_required(VERSION 3.10)
+
+set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")
+
+# Configuration provided via flutter tool.
+include(${EPHEMERAL_DIR}/generated_config.cmake)
+
+# TODO: Move the rest of this into files in ephemeral. See
+# https://github.com/flutter/flutter/issues/57146.
+
+# Serves the same purpose as list(TRANSFORM ... PREPEND ...),
+# which isn't available in 3.10.
+function(list_prepend LIST_NAME PREFIX)
+    set(NEW_LIST "")
+    foreach(element ${${LIST_NAME}})
+        list(APPEND NEW_LIST "${PREFIX}${element}")
+    endforeach(element)
+    set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
+endfunction()
+
+# === Flutter Library ===
+# System-level dependencies.
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
+pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
+pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
+
+set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")
+
+# Published to parent scope for install step.
+set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
+set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
+set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
+set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE)
+
+list(APPEND FLUTTER_LIBRARY_HEADERS
+  "fl_basic_message_channel.h"
+  "fl_binary_codec.h"
+  "fl_binary_messenger.h"
+  "fl_dart_project.h"
+  "fl_engine.h"
+  "fl_json_message_codec.h"
+  "fl_json_method_codec.h"
+  "fl_message_codec.h"
+  "fl_method_call.h"
+  "fl_method_channel.h"
+  "fl_method_codec.h"
+  "fl_method_response.h"
+  "fl_plugin_registrar.h"
+  "fl_plugin_registry.h"
+  "fl_standard_message_codec.h"
+  "fl_standard_method_codec.h"
+  "fl_string_codec.h"
+  "fl_value.h"
+  "fl_view.h"
+  "flutter_linux.h"
+)
+list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
+add_library(flutter INTERFACE)
+target_include_directories(flutter INTERFACE
+  "${EPHEMERAL_DIR}"
+)
+target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
+target_link_libraries(flutter INTERFACE
+  PkgConfig::GTK
+  PkgConfig::GLIB
+  PkgConfig::GIO
+)
+add_dependencies(flutter flutter_assemble)
+
+# === Flutter tool backend ===
+# _phony_ is a non-existent file to force this command to run every time,
+# since currently there's no way to get a full input/output list from the
+# flutter tool.
+add_custom_command(
+  OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
+    ${CMAKE_CURRENT_BINARY_DIR}/_phony_
+  COMMAND ${CMAKE_COMMAND} -E env
+    ${FLUTTER_TOOL_ENVIRONMENT}
+    "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
+      ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE}
+  VERBATIM
+)
+add_custom_target(flutter_assemble DEPENDS
+  "${FLUTTER_LIBRARY}"
+  ${FLUTTER_LIBRARY_HEADERS}
+)

apps/desktop/linux/flutter/generated_plugin_registrant.cc

@@ -0,0 +1,19 @@
+//
+//  Generated file. Do not edit.
+//
+
+// clang-format off
+
+#include "generated_plugin_registrant.h"
+
+#include <media_kit_libs_linux/media_kit_libs_linux_plugin.h>
+#include <media_kit_video/media_kit_video_plugin.h>
+
+void fl_register_plugins(FlPluginRegistry* registry) {
+  g_autoptr(FlPluginRegistrar) media_kit_libs_linux_registrar =
+      fl_plugin_registry_get_registrar_for_plugin(registry, "MediaKitLibsLinuxPlugin");
+  media_kit_libs_linux_plugin_register_with_registrar(media_kit_libs_linux_registrar);
+  g_autoptr(FlPluginRegistrar) media_kit_video_registrar =
+      fl_plugin_registry_get_registrar_for_plugin(registry, "MediaKitVideoPlugin");
+  media_kit_video_plugin_register_with_registrar(media_kit_video_registrar);
+}

apps/desktop/linux/flutter/generated_plugin_registrant.h

@@ -0,0 +1,15 @@
+//
+//  Generated file. Do not edit.
+//
+
+// clang-format off
+
+#ifndef GENERATED_PLUGIN_REGISTRANT_
+#define GENERATED_PLUGIN_REGISTRANT_
+
+#include <flutter_linux/flutter_linux.h>
+
+// Registers Flutter plugins.
+void fl_register_plugins(FlPluginRegistry* registry);
+
+#endif  // GENERATED_PLUGIN_REGISTRANT_

apps/desktop/linux/flutter/generated_plugins.cmake

@@ -0,0 +1,26 @@
+#
+# Generated file, do not edit.
+#
+
+list(APPEND FLUTTER_PLUGIN_LIST
+  media_kit_libs_linux
+  media_kit_video
+)
+
+list(APPEND FLUTTER_FFI_PLUGIN_LIST
+  jni
+)
+
+set(PLUGIN_BUNDLED_LIBRARIES)
+
+foreach(plugin ${FLUTTER_PLUGIN_LIST})
+  add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin})
+  target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin)
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
+endforeach(plugin)
+
+foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST})
+  add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin})
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries})
+endforeach(ffi_plugin)

apps/desktop/linux/runner/CMakeLists.txt

@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.13)
+project(runner LANGUAGES CXX)
+
+# Define the application target. To change its name, change BINARY_NAME in the
+# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer
+# work.
+#
+# Any new source files that you add to the application should be added here.
+add_executable(${BINARY_NAME}
+  "main.cc"
+  "my_application.cc"
+  "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
+)
+
+# Apply the standard set of build settings. This can be removed for applications
+# that need different build settings.
+apply_standard_settings(${BINARY_NAME})
+
+# Add preprocessor definitions for the application ID.
+add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
+
+# Add dependency libraries. Add any application-specific dependencies here.
+target_link_libraries(${BINARY_NAME} PRIVATE flutter)
+target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)
+
+target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}")

apps/desktop/linux/runner/main.cc

@@ -0,0 +1,6 @@
+#include "my_application.h"
+
+int main(int argc, char** argv) {
+  g_autoptr(MyApplication) app = my_application_new();
+  return g_application_run(G_APPLICATION(app), argc, argv);
+}

apps/desktop/linux/runner/my_application.cc

@@ -0,0 +1,148 @@
+#include "my_application.h"
+
+#include <flutter_linux/flutter_linux.h>
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+
+#include "flutter/generated_plugin_registrant.h"
+
+struct _MyApplication {
+  GtkApplication parent_instance;
+  char** dart_entrypoint_arguments;
+};
+
+G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION)
+
+// Called when first Flutter frame received.
+static void first_frame_cb(MyApplication* self, FlView* view) {
+  gtk_widget_show(gtk_widget_get_toplevel(GTK_WIDGET(view)));
+}
+
+// Implements GApplication::activate.
+static void my_application_activate(GApplication* application) {
+  MyApplication* self = MY_APPLICATION(application);
+  GtkWindow* window =
+      GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
+
+  // Use a header bar when running in GNOME as this is the common style used
+  // by applications and is the setup most users will be using (e.g. Ubuntu
+  // desktop).
+  // If running on X and not using GNOME then just use a traditional title bar
+  // in case the window manager does more exotic layout, e.g. tiling.
+  // If running on Wayland assume the header bar will work (may need changing
+  // if future cases occur).
+  gboolean use_header_bar = TRUE;
+#ifdef GDK_WINDOWING_X11
+  GdkScreen* screen = gtk_window_get_screen(window);
+  if (GDK_IS_X11_SCREEN(screen)) {
+    const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen);
+    if (g_strcmp0(wm_name, "GNOME Shell") != 0) {
+      use_header_bar = FALSE;
+    }
+  }
+#endif
+  if (use_header_bar) {
+    GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
+    gtk_widget_show(GTK_WIDGET(header_bar));
+    gtk_header_bar_set_title(header_bar, "watch_together");
+    gtk_header_bar_set_show_close_button(header_bar, TRUE);
+    gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
+  } else {
+    gtk_window_set_title(window, "watch_together");
+  }
+
+  gtk_window_set_default_size(window, 1280, 720);
+
+  g_autoptr(FlDartProject) project = fl_dart_project_new();
+  fl_dart_project_set_dart_entrypoint_arguments(
+      project, self->dart_entrypoint_arguments);
+
+  FlView* view = fl_view_new(project);
+  GdkRGBA background_color;
+  // Background defaults to black, override it here if necessary, e.g. #00000000
+  // for transparent.
+  gdk_rgba_parse(&background_color, "#000000");
+  fl_view_set_background_color(view, &background_color);
+  gtk_widget_show(GTK_WIDGET(view));
+  gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view));
+
+  // Show the window when Flutter renders.
+  // Requires the view to be realized so we can start rendering.
+  g_signal_connect_swapped(view, "first-frame", G_CALLBACK(first_frame_cb),
+                           self);
+  gtk_widget_realize(GTK_WIDGET(view));
+
+  fl_register_plugins(FL_PLUGIN_REGISTRY(view));
+
+  gtk_widget_grab_focus(GTK_WIDGET(view));
+}
+
+// Implements GApplication::local_command_line.
+static gboolean my_application_local_command_line(GApplication* application,
+                                                  gchar*** arguments,
+                                                  int* exit_status) {
+  MyApplication* self = MY_APPLICATION(application);
+  // Strip out the first argument as it is the binary name.
+  self->dart_entrypoint_arguments = g_strdupv(*arguments + 1);
+
+  g_autoptr(GError) error = nullptr;
+  if (!g_application_register(application, nullptr, &error)) {
+    g_warning("Failed to register: %s", error->message);
+    *exit_status = 1;
+    return TRUE;
+  }
+
+  g_application_activate(application);
+  *exit_status = 0;
+
+  return TRUE;
+}
+
+// Implements GApplication::startup.
+static void my_application_startup(GApplication* application) {
+  // MyApplication* self = MY_APPLICATION(object);
+
+  // Perform any actions required at application startup.
+
+  G_APPLICATION_CLASS(my_application_parent_class)->startup(application);
+}
+
+// Implements GApplication::shutdown.
+static void my_application_shutdown(GApplication* application) {
+  // MyApplication* self = MY_APPLICATION(object);
+
+  // Perform any actions required at application shutdown.
+
+  G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application);
+}
+
+// Implements GObject::dispose.
+static void my_application_dispose(GObject* object) {
+  MyApplication* self = MY_APPLICATION(object);
+  g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);
+  G_OBJECT_CLASS(my_application_parent_class)->dispose(object);
+}
+
+static void my_application_class_init(MyApplicationClass* klass) {
+  G_APPLICATION_CLASS(klass)->activate = my_application_activate;
+  G_APPLICATION_CLASS(klass)->local_command_line =
+      my_application_local_command_line;
+  G_APPLICATION_CLASS(klass)->startup = my_application_startup;
+  G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown;
+  G_OBJECT_CLASS(klass)->dispose = my_application_dispose;
+}
+
+static void my_application_init(MyApplication* self) {}
+
+MyApplication* my_application_new() {
+  // Set the program name to the application ID, which helps various systems
+  // like GTK and desktop environments map this running application to its
+  // corresponding .desktop file. This ensures better integration by allowing
+  // the application to be recognized beyond its binary name.
+  g_set_prgname(APPLICATION_ID);
+
+  return MY_APPLICATION(g_object_new(my_application_get_type(),
+                                     "application-id", APPLICATION_ID, "flags",
+                                     G_APPLICATION_NON_UNIQUE, nullptr));
+}

apps/desktop/linux/runner/my_application.h

@@ -0,0 +1,21 @@
+#ifndef FLUTTER_MY_APPLICATION_H_
+#define FLUTTER_MY_APPLICATION_H_
+
+#include <gtk/gtk.h>
+
+G_DECLARE_FINAL_TYPE(MyApplication,
+                     my_application,
+                     MY,
+                     APPLICATION,
+                     GtkApplication)
+
+/**
+ * my_application_new:
+ *
+ * Creates a new Flutter-based application.
+ *
+ * Returns: a new #MyApplication.
+ */
+MyApplication* my_application_new();
+
+#endif  // FLUTTER_MY_APPLICATION_H_

apps/desktop/pubspec.lock

@@ -0,0 +1,848 @@
+# Generated by pub
+# See https://dart.dev/tools/pub/glossary#lockfile
+packages:
+  android_file_picker:
+    dependency: transitive
+    description:
+      name: android_file_picker
+      sha256: "014c74ab48d452c3252465682375a7fe6ddf56abb908ec361f207a3c4ffb2444"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.1"
+  archive:
+    dependency: transitive
+    description:
+      name: archive
+      sha256: ace891da0862b0e4cabbb064ee3fd87b2728b898949fdb366d83fe98342c9f19
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.2.0"
+  args:
+    dependency: transitive
+    description:
+      name: args
+      sha256: d0481093c50b1da8910eb0bb301626d4d8eb7284aa739614d2b394ee09e3ea04
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.7.0"
+  async:
+    dependency: transitive
+    description:
+      name: async
+      sha256: e2eb0491ba5ddb6177742d2da23904574082139b07c1e33b8503b9f46f3e1a37
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.13.1"
+  boolean_selector:
+    dependency: transitive
+    description:
+      name: boolean_selector
+      sha256: "8aab1771e1243a5063b8b0ff68042d67334e3feab9e95b9490f9a6ebf73b42ea"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.2"
+  characters:
+    dependency: transitive
+    description:
+      name: characters
+      sha256: faf38497bda5ead2a8c7615f4f7939df04333478bf32e4173fcb06d428b5716b
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.1"
+  clock:
+    dependency: transitive
+    description:
+      name: clock
+      sha256: e51d50bca3217c9a9fa2b41a30e4a38971133f5f9ec7a3d57bae095007f1d28e
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.3"
+  code_assets:
+    dependency: transitive
+    description:
+      name: code_assets
+      sha256: cfd4f5f575a49c5f10ca856e9846073f1e6c3ee94912377eea5f6cefc5272941
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.0.0"
+  collection:
+    dependency: transitive
+    description:
+      name: collection
+      sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.19.1"
+  convert:
+    dependency: transitive
+    description:
+      name: convert
+      sha256: b30acd5944035672bc15c6b7a8b47d773e41e2f17de064350988c5d02adb1c68
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.2"
+  cross_file:
+    dependency: transitive
+    description:
+      name: cross_file
+      sha256: f141ea4f277af142a0356955707f6556f37b03947d39d55585981a06ca437bd6
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.5+5"
+  crypto:
+    dependency: transitive
+    description:
+      name: crypto
+      sha256: c8ea0233063ba03258fbcf2ca4d6dadfefe14f02fab57702265467a19f27fadf
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.7"
+  dbus:
+    dependency: transitive
+    description:
+      name: dbus
+      sha256: a48d5da28e89bd02196e80d81ed8d7954923d00a0f4a68cc20b575038f023383
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.7.15"
+  fake_async:
+    dependency: transitive
+    description:
+      name: fake_async
+      sha256: "5368f224a74523e8d2e7399ea1638b37aecfca824a3cc4dfdf77bf1fa905ac44"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.3.3"
+  ffi:
+    dependency: transitive
+    description:
+      name: ffi
+      sha256: "6d7fd89431262d8f3125e81b50d3847a091d846eafcd4fdb88dd06f36d705a45"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.0"
+  ffi_leak_tracker:
+    dependency: transitive
+    description:
+      name: ffi_leak_tracker
+      sha256: "4093d4ef9ca06ffe2786e73bfb25e22aa92112b9bb4ec941f11e3e6b61489a97"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.1.2"
+  file_picker:
+    dependency: "direct main"
+    description:
+      name: file_picker
+      sha256: "9be6aac79508dbcf8dac80a4fb20f27ce6f910837ca27e3670b9295995cc0110"
+      url: "https://pub.dev"
+    source: hosted
+    version: "12.3.0"
+  file_picker_darwin:
+    dependency: transitive
+    description:
+      name: file_picker_darwin
+      sha256: "59fa5394cfa5b6dc8bf491630cb17077b77b844adbb840df371e7be5355d6cf6"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.0"
+  file_picker_linux:
+    dependency: transitive
+    description:
+      name: file_picker_linux
+      sha256: bd52ff1e0048f29df95f913c55ad2991c72791d93e6c42241912c4bdee946cb9
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.0"
+  file_picker_platform_interface:
+    dependency: transitive
+    description:
+      name: file_picker_platform_interface
+      sha256: "0355558fd9af6da499d18e333d6b3beb44b0bf19e00933fccd15d18eb8d0e9ca"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.4.0"
+  file_picker_web:
+    dependency: transitive
+    description:
+      name: file_picker_web
+      sha256: "935560a9d29fa6f006f2855addebb88e88d438e13627d4cc24187033c106f227"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.0"
+  fixnum:
+    dependency: transitive
+    description:
+      name: fixnum
+      sha256: b6dc7065e46c974bc7c5f143080a6764ec7a4be6da1285ececdc37be96de53be
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.1"
+  flutter:
+    dependency: "direct main"
+    description: flutter
+    source: sdk
+    version: "0.0.0"
+  flutter_hooks:
+    dependency: transitive
+    description:
+      name: flutter_hooks
+      sha256: "8ae1f090e5f4ef5cfa6670ce1ab5dddadd33f3533a7f9ba19d9f958aa2a89f42"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.21.3+1"
+  flutter_lints:
+    dependency: "direct dev"
+    description:
+      name: flutter_lints
+      sha256: "5398f14efa795ffb7a33e9b6a08798b26a180edac4ad7db3f231e40f82ce11e1"
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.0.0"
+  flutter_test:
+    dependency: "direct dev"
+    description: flutter
+    source: sdk
+    version: "0.0.0"
+  flutter_web_plugins:
+    dependency: transitive
+    description: flutter
+    source: sdk
+    version: "0.0.0"
+  hive_ce:
+    dependency: "direct main"
+    description:
+      name: hive_ce
+      sha256: "8e9980e68643afb1e765d3af32b47996552a64e190d03faf622cea07c1294418"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.19.3"
+  hive_ce_flutter:
+    dependency: "direct main"
+    description:
+      name: hive_ce_flutter
+      sha256: "2677e95a333ff15af43ccd06af7eb7abbf1a4f154ea071997f3de4346cae913a"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.3.4"
+  hooks:
+    dependency: transitive
+    description:
+      name: hooks
+      sha256: eaac480a35ec0814146c2c48d96aaa829e0e44a7662c88ae84c9edf4bc35651f
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.0"
+  http:
+    dependency: transitive
+    description:
+      name: http
+      sha256: "87721a4a50b19c7f1d49001e51409bddc46303966ce89a65af4f4e6004896412"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.6.0"
+  http_parser:
+    dependency: transitive
+    description:
+      name: http_parser
+      sha256: "178d74305e7866013777bab2c3d8726205dc5a4dd935297175b19a23a2e66571"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.1.2"
+  image:
+    dependency: "direct main"
+    description:
+      name: image
+      sha256: "1976370a4df3091bb0f72409c187ad1f9132a818bc6b95ca59c0bae1c75c688e"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.9.2"
+  isolate_channel:
+    dependency: transitive
+    description:
+      name: isolate_channel
+      sha256: a9d3d620695bc984244dafae00b95e4319d6974b2d77f4b9e1eb4f2efe099094
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.6.1"
+  jni:
+    dependency: transitive
+    description:
+      name: jni
+      sha256: f038e58b4dc2c9037f50e233175086337e0b305e356d28211bf55f21c504cbd3
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.3"
+  jni_flutter:
+    dependency: transitive
+    description:
+      name: jni_flutter
+      sha256: b2310cdd4c18c65c081ab141a41efa94aa26c65431803703ece51996f174f351
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.3"
+  jni_util:
+    dependency: transitive
+    description:
+      name: jni_util
+      sha256: "1ba86da04a5f2bf18fde2edb235587e70c5b0fc5bd4ba955f46b00942c3fc35f"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.0"
+  json_annotation:
+    dependency: transitive
+    description:
+      name: json_annotation
+      sha256: "2a743920d81b7910627f68ee2c9ac1fc0bfee32b9fc3403587d7c6791ca12f80"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.12.0"
+  leak_tracker:
+    dependency: transitive
+    description:
+      name: leak_tracker
+      sha256: "33e2e26bdd85a0112ec15400c8cbffea70d0f9c3407491f672a2fad47915e2de"
+      url: "https://pub.dev"
+    source: hosted
+    version: "11.0.2"
+  leak_tracker_flutter_testing:
+    dependency: transitive
+    description:
+      name: leak_tracker_flutter_testing
+      sha256: "1dbc140bb5a23c75ea9c4811222756104fbcd1a27173f0c34ca01e16bea473c1"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.10"
+  leak_tracker_testing:
+    dependency: transitive
+    description:
+      name: leak_tracker_testing
+      sha256: "8d5a2d49f4a66b49744b23b018848400d23e54caf9463f4eb20df3eb8acb2eb1"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.2"
+  lints:
+    dependency: transitive
+    description:
+      name: lints
+      sha256: c35bb79562d980e9a453fc715854e1ed39e24e7d0297a880ef54e17f9874a9d7
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.1.1"
+  logging:
+    dependency: transitive
+    description:
+      name: logging
+      sha256: c8245ada5f1717ed44271ed1c26b8ce85ca3228fd2ffdb75468ab01979309d61
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.3.0"
+  matcher:
+    dependency: transitive
+    description:
+      name: matcher
+      sha256: "31bd099b47c10cd1aeb55146a2d46ce0277630ecef3f7dae54ad7873f36696cd"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.12.20"
+  material_color_utilities:
+    dependency: transitive
+    description:
+      name: material_color_utilities
+      sha256: "9c337007e82b1889149c82ed242ed1cb24a66044e30979c44912381e9be4c48b"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.13.0"
+  media_kit:
+    dependency: "direct main"
+    description:
+      name: media_kit
+      sha256: ae9e79597500c7ad6083a3c7b7b7544ddabfceacce7ae5c9709b0ec16a5d6643
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.6"
+  media_kit_libs_android_video:
+    dependency: transitive
+    description:
+      name: media_kit_libs_android_video
+      sha256: "3f6274e5ab2de512c286a25c327288601ee445ed8ac319e0ef0b66148bd8f76c"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.3.8"
+  media_kit_libs_ios_video:
+    dependency: transitive
+    description:
+      name: media_kit_libs_ios_video
+      sha256: b5382994eb37a4564c368386c154ad70ba0cc78dacdd3fb0cd9f30db6d837991
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.4"
+  media_kit_libs_linux:
+    dependency: transitive
+    description:
+      name: media_kit_libs_linux
+      sha256: "2b473399a49ec94452c4d4ae51cfc0f6585074398d74216092bf3d54aac37ecf"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.1"
+  media_kit_libs_macos_video:
+    dependency: transitive
+    description:
+      name: media_kit_libs_macos_video
+      sha256: f26aa1452b665df288e360393758f84b911f70ffb3878032e1aabba23aa1032d
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.4"
+  media_kit_libs_video:
+    dependency: "direct main"
+    description:
+      name: media_kit_libs_video
+      sha256: "2b235b5dac79c6020e01eef5022c6cc85fedc0df1738aadc6ea489daa12a92a9"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.7"
+  media_kit_libs_windows_video:
+    dependency: transitive
+    description:
+      name: media_kit_libs_windows_video
+      sha256: dff76da2778729ab650229e6b4ec6ec111eb5151431002cbd7ea304ff1f112ab
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.11"
+  media_kit_video:
+    dependency: "direct main"
+    description:
+      name: media_kit_video
+      sha256: afaa509e7b7e0bf247557a3a740cde903a52c34ace9810f94500e127bd7b043d
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.0.1"
+  meta:
+    dependency: transitive
+    description:
+      name: meta
+      sha256: "307249ce4ff29d58a18e97f6345f539382eb9c9c29ecda628900f31de0443dd9"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.19.0"
+  mime:
+    dependency: transitive
+    description:
+      name: mime
+      sha256: bd47de35f07e27267e69c8c8b22edf9473bfee170a60d60fcc93730c5144b7f6
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.0"
+  objective_c:
+    dependency: transitive
+    description:
+      name: objective_c
+      sha256: ad56fd53a78ff6b1472fa59ff2a4e8b8ccabafc586fc263a1dfad0b99b5553e3
+      url: "https://pub.dev"
+    source: hosted
+    version: "9.6.0"
+  package_config:
+    dependency: transitive
+    description:
+      name: package_config
+      sha256: ffcf4cf3d6c0b74ac43708d9f56625506e8a68aa935abe9d267a7330f320eb5d
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.0"
+  package_info_plus:
+    dependency: transitive
+    description:
+      name: package_info_plus
+      sha256: "127e1751e37ffb2ff4658beeaca77bad0c27bf5f932bd3a501c2296926d4b481"
+      url: "https://pub.dev"
+    source: hosted
+    version: "10.2.1"
+  package_info_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: package_info_plus_platform_interface
+      sha256: db762cb2f4f25ee60fb6359773861b0f199e00b90d237bd85a76a1e806b46ef4
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.1.0"
+  path:
+    dependency: transitive
+    description:
+      name: path
+      sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.9.1"
+  path_provider:
+    dependency: "direct main"
+    description:
+      name: path_provider
+      sha256: a7f4874f987173da295a61c181b8ee71dab59b332a486b391babf26a1b884825
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.6"
+  path_provider_android:
+    dependency: transitive
+    description:
+      name: path_provider_android
+      sha256: "69cbd515a62b94d32a7944f086b2f82b4ac40a1d45bebfc00813a430ab2dabcd"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.3.1"
+  path_provider_foundation:
+    dependency: transitive
+    description:
+      name: path_provider_foundation
+      sha256: "2a376b7d6392d80cd3705782d2caa734ca4727776db0b6ec36ef3f1855197699"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.6.0"
+  path_provider_linux:
+    dependency: transitive
+    description:
+      name: path_provider_linux
+      sha256: "58c2005f147315b11e9b4a7bc889cd5203e250cba8e3f012dae259b4972b5c16"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.2"
+  path_provider_platform_interface:
+    dependency: transitive
+    description:
+      name: path_provider_platform_interface
+      sha256: "484838772624c3a4b94f1e44a3e19897fee738f2d5c4ce448443b0417f7c9dda"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.3"
+  path_provider_windows:
+    dependency: transitive
+    description:
+      name: path_provider_windows
+      sha256: bd6f00dbd873bfb70d0761682da2b3a2c2fccc2b9e84c495821639601d81afe7
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.3.0"
+  petitparser:
+    dependency: transitive
+    description:
+      name: petitparser
+      sha256: "91bd59303e9f769f108f8df05e371341b15d59e995e6806aefab827b58336675"
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.0.2"
+  platform:
+    dependency: transitive
+    description:
+      name: platform
+      sha256: a36d119c13416516a7b5913fbe8af8531e11633d784c550b2125f76c758524ec
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.2.0"
+  plugin_platform_interface:
+    dependency: transitive
+    description:
+      name: plugin_platform_interface
+      sha256: "4820fbfdb9478b1ebae27888254d445073732dae3d6ea81f0b7e06d5dedc3f02"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.8"
+  posix:
+    dependency: transitive
+    description:
+      name: posix
+      sha256: bc1bad54ad2b735816e31f8d4600cfde6c7839975085ddfbca48b6c9f7c4044e
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.5.2"
+  preact_signals:
+    dependency: transitive
+    description:
+      name: preact_signals
+      sha256: "18f45e7f91a4dfad8bd0138efa6b85770bb25e13278b863fdaafd28a56579b16"
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.0.0"
+  pub_semver:
+    dependency: transitive
+    description:
+      name: pub_semver
+      sha256: "261236774e8b1d69cfc6b9eabbc96c40f25e7a2d6b171f3385d4f65d5734fb24"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.1"
+  record_use:
+    dependency: transitive
+    description:
+      name: record_use
+      sha256: "1cb8564af8d43b464294411db9217f5ec04891c6f22ee2c32d73ae05e88a6bd2"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.1"
+  relic:
+    dependency: transitive
+    description:
+      name: relic
+      sha256: d917b188dd1b6838c630d1904a1e26b040e6647406f2aab01b10fdf0ca051c12
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.0"
+  relic_core:
+    dependency: transitive
+    description:
+      name: relic_core
+      sha256: c2f7638d56fdf144a035d17eb8e93fb30fe53bd105fd81c31393f8be4f43ecdc
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.0"
+  relic_io:
+    dependency: transitive
+    description:
+      name: relic_io
+      sha256: d64a9f309943200ec7a45b2a127cbc5abf4dd6603159a179396d66b932a15f1f
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.0"
+  safe_local_storage:
+    dependency: transitive
+    description:
+      name: safe_local_storage
+      sha256: "494b982d5edb71030650ea463d939670e91b232b588323dc75229d2c5f23e7b7"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.0.6"
+  signals:
+    dependency: "direct main"
+    description:
+      name: signals
+      sha256: "3b6be91d04808b542612a525eaeb1875e50be153671e618a42f74e0607088ecd"
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.1.0"
+  signals_core:
+    dependency: transitive
+    description:
+      name: signals_core
+      sha256: "04d7ccb0265264191a4e2666050031129f47c2bbf4ac3f31f6586889a9903b62"
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.0.0"
+  signals_flutter:
+    dependency: transitive
+    description:
+      name: signals_flutter
+      sha256: f0285fd2f98d720724df879c258dc41725f260f8e5b1184655ef64ba679197ad
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.1.0"
+  signals_hooks:
+    dependency: transitive
+    description:
+      name: signals_hooks
+      sha256: af6c2c4be47f06214292fedab6f6e943433c02086c956eeaffe45c4a23a57413
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.1.0"
+  sky_engine:
+    dependency: transitive
+    description: flutter
+    source: sdk
+    version: "0.0.0"
+  source_span:
+    dependency: transitive
+    description:
+      name: source_span
+      sha256: "56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.10.2"
+  stack_trace:
+    dependency: transitive
+    description:
+      name: stack_trace
+      sha256: "277654b3034d17ac6f9f1cb5595db011b1d5d41e8806866db28e0abaa101c490"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.12.2"
+  stream_channel:
+    dependency: transitive
+    description:
+      name: stream_channel
+      sha256: "969e04c80b8bcdf826f8f16579c7b14d780458bd97f56d107d3950fdbeef059d"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.4"
+  string_scanner:
+    dependency: transitive
+    description:
+      name: string_scanner
+      sha256: "921cd31725b72fe181906c6a94d987c78e3b98c2e205b397ea399d4054872b43"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.1"
+  sync_relay_core:
+    dependency: "direct main"
+    description:
+      path: "../../packages/core"
+      relative: true
+    source: path
+    version: "0.1.0"
+  sync_relay_server:
+    dependency: "direct main"
+    description:
+      path: "../../packages/server"
+      relative: true
+    source: path
+    version: "0.1.0"
+  synchronized:
+    dependency: transitive
+    description:
+      name: synchronized
+      sha256: "397b146f97613b83d84bdccb439bc8d0f3aebb6c1d14a9641e6f24201c490b2d"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.4.2"
+  term_glyph:
+    dependency: transitive
+    description:
+      name: term_glyph
+      sha256: "7f554798625ea768a7518313e58f83891c7f5024f88e46e7182a4558850a4b8e"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.2"
+  test_api:
+    dependency: transitive
+    description:
+      name: test_api
+      sha256: "2a122cbe059f8b610d3a5415f42e255b6c17b1f21eee1d960f31080237fb4f11"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.7.12"
+  typed_data:
+    dependency: transitive
+    description:
+      name: typed_data
+      sha256: f9049c039ebfeb4cf7a7104a675823cd72dba8297f264b6637062516699fa006
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.0"
+  universal_platform:
+    dependency: transitive
+    description:
+      name: universal_platform
+      sha256: "64e16458a0ea9b99260ceb5467a214c1f298d647c659af1bff6d3bf82536b1ec"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.0"
+  uri_parser:
+    dependency: transitive
+    description:
+      name: uri_parser
+      sha256: "051c62e5f693de98ca9f130ee707f8916e2266945565926be3ff20659f7853ce"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.2"
+  uuid:
+    dependency: transitive
+    description:
+      name: uuid
+      sha256: "9b129329f58692f6e6578329498a8fe9fbe98f090beb764ffbb8ee2eadd01dcd"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.6.0"
+  vector_math:
+    dependency: transitive
+    description:
+      name: vector_math
+      sha256: f36f9f3be64c6198714492bb455c11056e33e2f85d9a0b676a48301e44fdcf47
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.4.2"
+  vm_service:
+    dependency: transitive
+    description:
+      name: vm_service
+      sha256: "5f37239c4851efcef929cea7824e76df7f2f0970aef85d66bbc430afa40e72f0"
+      url: "https://pub.dev"
+    source: hosted
+    version: "15.3.0"
+  wakelock_plus:
+    dependency: transitive
+    description:
+      name: wakelock_plus
+      sha256: "22b3e7e937721de70e63c85e7139f4ac781dc22863b9262431a53ac030eb074b"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.8.0"
+  wakelock_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: wakelock_plus_platform_interface
+      sha256: "764c25504562abc8ac3406f5d175f126b276e6ba916c7c2675690b73368ca384"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.7.0"
+  web:
+    dependency: transitive
+    description:
+      name: web
+      sha256: "868d88a33d8a87b18ffc05f9f030ba328ffefba92d6c127917a2ba740f9cfe4a"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.1"
+  web_socket:
+    dependency: transitive
+    description:
+      name: web_socket
+      sha256: "34d64019aa8e36bf9842ac014bb5d2f5586ca73df5e4d9bf5c936975cae6982c"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.1"
+  web_socket_channel:
+    dependency: "direct main"
+    description:
+      name: web_socket_channel
+      sha256: d645757fb0f4773d602444000a8131ff5d48c9e47adfe9772652dd1a4f2d45c8
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.3"
+  win32:
+    dependency: transitive
+    description:
+      name: win32
+      sha256: a0b93865d5644f11cf6a8c3f6db909f1ec168958b5805f6cc684adea957cd63d
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.4.0"
+  windows_file_picker:
+    dependency: transitive
+    description:
+      name: windows_file_picker
+      sha256: "62e6e6e115231d1d1d71c7b5883b4091ce3e0190e49548dfb0ff8cba8d91ad96"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.3.0"
+  xdg_directories:
+    dependency: transitive
+    description:
+      name: xdg_directories
+      sha256: "7a3f37b05d989967cdddcbb571f1ea834867ae2faa29725fd085180e0883aa15"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.0"
+  xml:
+    dependency: transitive
+    description:
+      name: xml
+      sha256: "67f0aff7be013d107995e9b75bf4e7f2c3ef2dfdb2c8e68024bba0a7fd5756a4"
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.0.1"
+  yaml:
+    dependency: transitive
+    description:
+      name: yaml
+      sha256: f67cdd8e07d3c6329146aaef1ba043542b3134c12489f553ca9a7435d1068aea
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.4"
+sdks:
+  dart: ">=3.14.0-0 <4.0.0"
+  flutter: ">=3.44.0"

apps/desktop/pubspec.yaml

@@ -0,0 +1,30 @@
+name: watch_together
+description: Watch-together desktop app (working title, repo sync_relay_project). One binary.
+publish_to: none
+version: 0.1.0
+environment:
+  sdk: '>=3.14.0-0 <4.0.0'
+
+dependencies:
+  flutter:
+    sdk: flutter
+  signals: ^7.0.0
+  media_kit: ^1.1.0
+  media_kit_video: ^2.0.1
+  media_kit_libs_video: ^1.0.0
+  path_provider: ^2.1.0
+  web_socket_channel: ^3.0.0
+  sync_relay_core:
+    path: ../../packages/core
+  sync_relay_server:
+    path: ../../packages/server
+  file_picker: ^12.3.0
+  hive_ce: ^2.19.3
+  hive_ce_flutter: ^2.3.4
+  image: ^4.9.2
+dev_dependencies:
+  flutter_test:
+    sdk: flutter
+  flutter_lints: ^5.0.0
+flutter:
+  uses-material-design: true

apps/desktop/test/coord_presence_test.dart

@@ -0,0 +1,59 @@
+import 'dart:async';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:media_kit/media_kit.dart';
+import 'package:sync_relay_core/core.dart';
+import 'package:sync_relay_server/server.dart';
+import 'package:watch_together/src/session/session_coordinator.dart';
+
+Future<void> _poll(
+  FutureOr<bool> Function() cond,
+  String what, {
+  Duration timeout = const Duration(seconds: 15),
+}) async {
+  final deadline = DateTime.now().add(timeout);
+  while (DateTime.now().isBefore(deadline)) {
+    if (await cond()) return;
+    await Future.delayed(const Duration(milliseconds: 200));
+  }
+  fail('timed out waiting for $what');
+}
+
+void main() {
+  test(
+    'dead server clears room state and reconnects instead of freezing',
+    timeout: const Timeout(Duration(minutes: 2)),
+    () async {
+      MediaKit.ensureInitialized();
+      final server = RoomServer(
+          const AppConfig(port: 0, secret: 'presence', name: 'presence'));
+      await server.start();
+      final coord = SessionCoordinator();
+      try {
+        await coord.connect(ConnectParams(
+          host: '127.0.0.1',
+          port: server.boundPort,
+          secret: 'presence',
+          name: 'watcher',
+        ));
+        await coord.playback.player.setVolume(0);
+        await _poll(() => coord.room.peek() != null, 'room state to arrive');
+        expect(coord.reconnecting.peek(), isFalse);
+
+        await server.stop();
+        await _poll(
+          () => coord.reconnecting.peek() == true,
+          'reconnect loop to engage',
+        );
+        await _poll(
+          () => coord.room.peek() == null,
+          'stale room (ghost members) to clear',
+        );
+        coord.cancelReconnect();
+        expect(coord.reconnecting.peek(), isFalse);
+      } finally {
+        await coord.dispose();
+      }
+    },
+  );
+}

apps/desktop/test/media_input_test.dart

@@ -0,0 +1,33 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:watch_together/src/widgets/media_input.dart';
+
+void main() {
+  test('http url routes to linkUrl', () {
+    expect(parseMediaInput('http://example.com/v.mp4'),
+        (mediaPath: '', linkUrl: 'http://example.com/v.mp4'));
+  });
+
+  test('https url routes to linkUrl', () {
+    expect(parseMediaInput('https://example.com/v.mp4'),
+        (mediaPath: '', linkUrl: 'https://example.com/v.mp4'));
+  });
+
+  test('scheme match is case-insensitive and trimmed', () {
+    expect(parseMediaInput('  HTTPS://example.com/v.mp4  '),
+        (mediaPath: '', linkUrl: 'HTTPS://example.com/v.mp4'));
+  });
+
+  test('file path routes to mediaPath', () {
+    expect(parseMediaInput('/home/u/Videos/chiyo.mp4'),
+        (mediaPath: '/home/u/Videos/chiyo.mp4', linkUrl: ''));
+  });
+
+  test('empty input stays empty', () {
+    expect(parseMediaInput('   '), (mediaPath: '', linkUrl: ''));
+  });
+
+  test('non-http scheme stays a path', () {
+    expect(parseMediaInput('ftp://example.com/v.mp4'),
+        (mediaPath: 'ftp://example.com/v.mp4', linkUrl: ''));
+  });
+}

apps/desktop/test/room_diff_test.dart

@@ -0,0 +1,159 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:sync_relay_core/core.dart';
+import 'package:watch_together/src/sync/room_diff.dart';
+
+RoomBroadcast _room({
+  int eventId = 0,
+  String transport = 'held',
+  double position = 10.0,
+  int mediaId = 1,
+}) {
+  final now = DateTime.now().toUtc();
+  return RoomBroadcast(
+    eventId: eventId,
+    transport: transport,
+    position: position,
+    serverTime: now,
+    mediaId: mediaId,
+    members: const [],
+  );
+}
+
+RoomBroadcast _roomWithMembers(List<MemberView> members,
+    {String transport = 'playing'}) {
+  final now = DateTime.now().toUtc();
+  return RoomBroadcast(
+    eventId: 3,
+    transport: transport,
+    position: 10.0,
+    serverTime: now,
+    mediaId: 1,
+    members: members,
+  );
+}
+
+void main() {
+  test('initial diff seeks to room edge and sets transport', () {
+    final diff = RoomDiff();
+    final actions = diff.diff(_room(), 0, DateTime.now().toUtc());
+    expect(actions.whereType<SeekAction>().single.position, closeTo(10.0, 1.0));
+    expect(actions.whereType<TransportAction>().single.playing, isFalse);
+  });
+
+  test('same event small drift does nothing', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(), 0, now);
+    final actions = diff.diff(_room(), 10.5, now);
+    expect(actions, isEmpty);
+  });
+
+  test('ahead drift latches slowdown, resets inside 0.1', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(), 0, now);
+    var actions = diff.diff(_room(), 13.0, now);
+    expect(actions.whereType<RateAction>().single.rate, 0.95);
+    actions = diff.diff(_room(), 12.0, now);
+    expect(actions, isEmpty);
+    actions = diff.diff(_room(), 10.05, now);
+    expect(actions.whereType<RateAction>().single.rate, 1.0);
+  });
+
+  test('eventId jump seeks and resets rate', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(), 0, now);
+    diff.diff(_room(), 13.0, now);
+    final actions =
+        diff.diff(_room(eventId: 1, position: 90.0), 13.0, now);
+    expect(actions.whereType<SeekAction>().single.position, closeTo(90.0, 1.0));
+    expect(actions.whereType<RateAction>().single.rate, 1.0);
+  });
+
+  test('media swap seeks zero and pauses', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(transport: 'playing'), 10.0, now);
+    final actions = diff.diff(
+        _room(eventId: 2, transport: 'held', position: 0, mediaId: 2),
+        50.0,
+        now);
+    expect(actions.whereType<SeekAction>().single.position, 0);
+    expect(actions.whereType<TransportAction>().single.playing, isFalse);
+  });
+
+  group('seek debounce while playing', () {
+    RoomBroadcast playing({int eventId = 5, double position = 100.0}) => _room(
+        eventId: eventId, transport: 'playing', position: position);
+
+    test('fresh big drift is swallowed first, seeks after window', () {
+      final diff = RoomDiff();
+      final t0 = DateTime.now().toUtc();
+      diff.diff(playing(), 100.0, t0);
+      var actions = diff.diff(playing(), 120.0, t0);
+      expect(actions.whereType<SeekAction>(), isEmpty,
+          reason: 'user scrub must not be yanked back before detector runs');
+      actions = diff.diff(
+          playing(), 120.0, t0.add(RoomDiff.debounceWindow + const Duration(milliseconds: 100)));
+      expect(actions.whereType<SeekAction>().single.position,
+          closeTo(102.0, 3.0),
+          reason: 'genuine drift still converges after the window');
+    });
+
+    test('new eventId seeks immediately (echo of promoted seek)', () {
+      final diff = RoomDiff();
+      final t0 = DateTime.now().toUtc();
+      diff.diff(playing(), 100.0, t0);
+      diff.diff(playing(), 120.0, t0);
+      final actions = diff.diff(playing(eventId: 6, position: 120.0), 120.0, t0);
+      expect(actions.whereType<SeekAction>().single.position,
+          closeTo(120.0, 2.0));
+    });
+
+    test('held transport debounces the same way (detector promotes)', () {
+      final diff = RoomDiff();
+      final t0 = DateTime.now().toUtc();
+      diff.diff(_room(), 10.0, t0);
+      var actions = diff.diff(_room(), 60.0, t0);
+      expect(actions.whereType<SeekAction>(), isEmpty);
+      actions = diff.diff(_room(), 60.0,
+          t0.add(RoomDiff.debounceWindow + const Duration(milliseconds: 100)));
+      expect(actions.whereType<SeekAction>().single.position,
+          closeTo(10.0, 3.0));
+    });
+  });
+
+  group('local play gate', () {
+    const ready = MemberView(
+        id: 'm1',
+        name: 'a',
+        ready: true,
+        inSet: true,
+        buffered: 9,
+        stale: false);
+    const catchingUp = MemberView(
+        id: 'm2',
+        name: 'b',
+        ready: false,
+        inSet: false,
+        buffered: 0,
+        stale: false);
+    const unreadyInSet = MemberView(
+        id: 'm3',
+        name: 'c',
+        ready: false,
+        inSet: true,
+        buffered: 9,
+        stale: false);
+
+    test('only in-set ready members may follow transport to playing', () {
+      final room = _roomWithMembers([ready, catchingUp, unreadyInSet]);
+      expect(localPlayAllowed(room, 'm1'), isTrue);
+      expect(localPlayAllowed(room, 'm2'), isFalse);
+      expect(localPlayAllowed(room, 'm3'), isFalse);
+      expect(localPlayAllowed(room, 'nope'), isFalse);
+      expect(localPlayAllowed(room, ''), isFalse);
+    });
+  });
+}

apps/desktop/test/sync_playback_e2e_test.dart

@@ -0,0 +1,93 @@
+import 'dart:async';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:media_kit/media_kit.dart';
+import 'package:sync_relay_core/core.dart';
+import 'package:sync_relay_server/server.dart';
+import 'package:watch_together/src/session/session_coordinator.dart';
+
+const _port = 18080;
+const _secret = 'e2e-secret';
+const _mediaPath = '/home/foxyz/Videos/chiyo.mp4';
+
+Future<void> _poll(
+  FutureOr<bool> Function() cond,
+  String what, {
+  Duration timeout = const Duration(seconds: 30),
+}) async {
+  final deadline = DateTime.now().add(timeout);
+  while (DateTime.now().isBefore(deadline)) {
+    if (await cond()) return;
+    await Future.delayed(const Duration(milliseconds: 200));
+  }
+  fail('timed out waiting for $what');
+}
+
+Future<void> _quiet(SessionCoordinator c) async {
+  await c.playback.player.setVolume(0);
+  try {
+    final dynamic platform = c.playback.player.platform;
+    await platform?.setProperty('loop-file', 'inf');
+  } catch (_) {}
+}
+
+void main() {
+  test(
+    'two app coordinators split play on readiness over real server',
+    timeout: const Timeout(Duration(minutes: 4)),
+    () async {
+      MediaKit.ensureInitialized();
+      final server = RoomServer(const AppConfig(
+        port: _port,
+        secret: _secret,
+        name: 'room',
+        mediaPath: _mediaPath,
+      ));
+      await server.start();
+
+      final host = SessionCoordinator();
+      final viewer = SessionCoordinator();
+      try {
+        await host.connect(const ConnectParams(
+          host: '127.0.0.1',
+          port: _port,
+          secret: _secret,
+          name: 'host',
+        ));
+        await viewer.connect(const ConnectParams(
+          host: '127.0.0.1',
+          port: _port,
+          secret: _secret,
+          name: 'viewer',
+        ));
+        await _quiet(host);
+        await _quiet(viewer);
+
+        expect(host.playback.player.state.playing, isFalse,
+            reason: 'media must open paused, not autoplay');
+        expect(viewer.playback.player.state.playing, isFalse);
+
+        await _poll(() => host.room.peek() != null, 'host room state');
+        host.toggleReady();
+        await Future.delayed(const Duration(seconds: 5));
+        expect(host.room.peek()?.transport, 'held',
+            reason: 'one Space with company present must not solo-play');
+        expect(host.playback.player.state.playing, isFalse);
+        expect(viewer.playback.player.state.playing, isFalse);
+
+        viewer.toggleReady();
+        await _poll(
+          () =>
+              host.room.peek()?.transport == 'playing' &&
+              viewer.playback.player.state.playing &&
+              host.playback.player.state.playing,
+          'both players playing once quorum readies',
+        );
+      } finally {
+        await host.dispose();
+        await viewer.dispose();
+        await server.stop();
+      }
+    },
+  );
+}

apps/desktop/windows/.gitignore

@@ -0,0 +1,17 @@
+flutter/ephemeral/
+
+# Visual Studio user-specific files.
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# Visual Studio build-related files.
+x64/
+x86/
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/

apps/desktop/windows/CMakeLists.txt

@@ -0,0 +1,108 @@
+# Project-level configuration.
+cmake_minimum_required(VERSION 3.14)
+project(watch_together LANGUAGES CXX)
+
+# The name of the executable created for the application. Change this to change
+# the on-disk name of your application.
+set(BINARY_NAME "watch_together")
+
+# Explicitly opt in to modern CMake behaviors to avoid warnings with recent
+# versions of CMake.
+cmake_policy(VERSION 3.14...3.25)
+
+# Define build configuration option.
+get_property(IS_MULTICONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(IS_MULTICONFIG)
+  set(CMAKE_CONFIGURATION_TYPES "Debug;Profile;Release"
+    CACHE STRING "" FORCE)
+else()
+  if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE "Debug" CACHE
+      STRING "Flutter build mode" FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+      "Debug" "Profile" "Release")
+  endif()
+endif()
+# Define settings for the Profile build mode.
+set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
+set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
+set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE}")
+set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE}")
+
+# Use Unicode for all projects.
+add_definitions(-DUNICODE -D_UNICODE)
+
+# Compilation settings that should be applied to most targets.
+#
+# Be cautious about adding new options here, as plugins use this function by
+# default. In most cases, you should add new options to specific targets instead
+# of modifying this function.
+function(APPLY_STANDARD_SETTINGS TARGET)
+  target_compile_features(${TARGET} PUBLIC cxx_std_17)
+  target_compile_options(${TARGET} PRIVATE /W4 /WX /wd"4100")
+  target_compile_options(${TARGET} PRIVATE /EHsc)
+  target_compile_definitions(${TARGET} PRIVATE "_HAS_EXCEPTIONS=0")
+  target_compile_definitions(${TARGET} PRIVATE "$<$<CONFIG:Debug>:_DEBUG>")
+endfunction()
+
+# Flutter library and tool build rules.
+set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
+add_subdirectory(${FLUTTER_MANAGED_DIR})
+
+# Application build; see runner/CMakeLists.txt.
+add_subdirectory("runner")
+
+
+# Generated plugin build rules, which manage building the plugins and adding
+# them to the application.
+include(flutter/generated_plugins.cmake)
+
+
+# === Installation ===
+# Support files are copied into place next to the executable, so that it can
+# run in place. This is done instead of making a separate bundle (as on Linux)
+# so that building and running from within Visual Studio will work.
+set(BUILD_BUNDLE_DIR "$<TARGET_FILE_DIR:${BINARY_NAME}>")
+# Make the "install" step default, as it's required to run.
+set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1)
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+  set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
+endif()
+
+set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
+set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}")
+
+install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
+  COMPONENT Runtime)
+
+install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
+  COMPONENT Runtime)
+
+install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+  COMPONENT Runtime)
+
+if(PLUGIN_BUNDLED_LIBRARIES)
+  install(FILES "${PLUGIN_BUNDLED_LIBRARIES}"
+    DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+    COMPONENT Runtime)
+endif()
+
+# Copy the native assets provided by the build.dart from all packages.
+set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/windows/")
+install(DIRECTORY "${NATIVE_ASSETS_DIR}"
+   DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+   COMPONENT Runtime)
+
+# Fully re-copy the assets directory on each build to avoid having stale files
+# from a previous install.
+set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
+install(CODE "
+  file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
+  " COMPONENT Runtime)
+install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
+  DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
+
+# Install the AOT library on non-Debug builds only.
+install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
+  CONFIGURATIONS Profile;Release
+  COMPONENT Runtime)

apps/desktop/windows/flutter/CMakeLists.txt

@@ -0,0 +1,109 @@
+# This file controls Flutter-level build steps. It should not be edited.
+cmake_minimum_required(VERSION 3.14)
+
+set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")
+
+# Configuration provided via flutter tool.
+include(${EPHEMERAL_DIR}/generated_config.cmake)
+
+# TODO: Move the rest of this into files in ephemeral. See
+# https://github.com/flutter/flutter/issues/57146.
+set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper")
+
+# Set fallback configurations for older versions of the flutter tool.
+if (NOT DEFINED FLUTTER_TARGET_PLATFORM)
+  set(FLUTTER_TARGET_PLATFORM "windows-x64")
+endif()
+
+# === Flutter Library ===
+set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/flutter_windows.dll")
+
+# Published to parent scope for install step.
+set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
+set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
+set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
+set(AOT_LIBRARY "${PROJECT_DIR}/build/windows/app.so" PARENT_SCOPE)
+
+list(APPEND FLUTTER_LIBRARY_HEADERS
+  "flutter_export.h"
+  "flutter_windows.h"
+  "flutter_messenger.h"
+  "flutter_plugin_registrar.h"
+  "flutter_texture_registrar.h"
+)
+list(TRANSFORM FLUTTER_LIBRARY_HEADERS PREPEND "${EPHEMERAL_DIR}/")
+add_library(flutter INTERFACE)
+target_include_directories(flutter INTERFACE
+  "${EPHEMERAL_DIR}"
+)
+target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib")
+add_dependencies(flutter flutter_assemble)
+
+# === Wrapper ===
+list(APPEND CPP_WRAPPER_SOURCES_CORE
+  "core_implementations.cc"
+  "standard_codec.cc"
+)
+list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/")
+list(APPEND CPP_WRAPPER_SOURCES_PLUGIN
+  "plugin_registrar.cc"
+)
+list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/")
+list(APPEND CPP_WRAPPER_SOURCES_APP
+  "flutter_engine.cc"
+  "flutter_view_controller.cc"
+)
+list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/")
+
+# Wrapper sources needed for a plugin.
+add_library(flutter_wrapper_plugin STATIC
+  ${CPP_WRAPPER_SOURCES_CORE}
+  ${CPP_WRAPPER_SOURCES_PLUGIN}
+)
+apply_standard_settings(flutter_wrapper_plugin)
+set_target_properties(flutter_wrapper_plugin PROPERTIES
+  POSITION_INDEPENDENT_CODE ON)
+set_target_properties(flutter_wrapper_plugin PROPERTIES
+  CXX_VISIBILITY_PRESET hidden)
+target_link_libraries(flutter_wrapper_plugin PUBLIC flutter)
+target_include_directories(flutter_wrapper_plugin PUBLIC
+  "${WRAPPER_ROOT}/include"
+)
+add_dependencies(flutter_wrapper_plugin flutter_assemble)
+
+# Wrapper sources needed for the runner.
+add_library(flutter_wrapper_app STATIC
+  ${CPP_WRAPPER_SOURCES_CORE}
+  ${CPP_WRAPPER_SOURCES_APP}
+)
+apply_standard_settings(flutter_wrapper_app)
+target_link_libraries(flutter_wrapper_app PUBLIC flutter)
+target_include_directories(flutter_wrapper_app PUBLIC
+  "${WRAPPER_ROOT}/include"
+)
+add_dependencies(flutter_wrapper_app flutter_assemble)
+
+# === Flutter tool backend ===
+# _phony_ is a non-existent file to force this command to run every time,
+# since currently there's no way to get a full input/output list from the
+# flutter tool.
+set(PHONY_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/_phony_")
+set_source_files_properties("${PHONY_OUTPUT}" PROPERTIES SYMBOLIC TRUE)
+add_custom_command(
+  OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
+    ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN}
+    ${CPP_WRAPPER_SOURCES_APP}
+    ${PHONY_OUTPUT}
+  COMMAND ${CMAKE_COMMAND} -E env
+    ${FLUTTER_TOOL_ENVIRONMENT}
+    "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.bat"
+      ${FLUTTER_TARGET_PLATFORM} $<CONFIG>
+  VERBATIM
+)
+add_custom_target(flutter_assemble DEPENDS
+  "${FLUTTER_LIBRARY}"
+  ${FLUTTER_LIBRARY_HEADERS}
+  ${CPP_WRAPPER_SOURCES_CORE}
+  ${CPP_WRAPPER_SOURCES_PLUGIN}
+  ${CPP_WRAPPER_SOURCES_APP}
+)

apps/desktop/windows/flutter/generated_plugin_registrant.cc

@@ -0,0 +1,17 @@
+//
+//  Generated file. Do not edit.
+//
+
+// clang-format off
+
+#include "generated_plugin_registrant.h"
+
+#include <media_kit_libs_windows_video/media_kit_libs_windows_video_plugin_c_api.h>
+#include <media_kit_video/media_kit_video_plugin_c_api.h>
+
+void RegisterPlugins(flutter::PluginRegistry* registry) {
+  MediaKitLibsWindowsVideoPluginCApiRegisterWithRegistrar(
+      registry->GetRegistrarForPlugin("MediaKitLibsWindowsVideoPluginCApi"));
+  MediaKitVideoPluginCApiRegisterWithRegistrar(
+      registry->GetRegistrarForPlugin("MediaKitVideoPluginCApi"));
+}

apps/desktop/windows/flutter/generated_plugin_registrant.h

@@ -0,0 +1,15 @@
+//
+//  Generated file. Do not edit.
+//
+
+// clang-format off
+
+#ifndef GENERATED_PLUGIN_REGISTRANT_
+#define GENERATED_PLUGIN_REGISTRANT_
+
+#include <flutter/plugin_registry.h>
+
+// Registers Flutter plugins.
+void RegisterPlugins(flutter::PluginRegistry* registry);
+
+#endif  // GENERATED_PLUGIN_REGISTRANT_

apps/desktop/windows/flutter/generated_plugins.cmake

@@ -0,0 +1,26 @@
+#
+# Generated file, do not edit.
+#
+
+list(APPEND FLUTTER_PLUGIN_LIST
+  media_kit_libs_windows_video
+  media_kit_video
+)
+
+list(APPEND FLUTTER_FFI_PLUGIN_LIST
+  jni
+)
+
+set(PLUGIN_BUNDLED_LIBRARIES)
+
+foreach(plugin ${FLUTTER_PLUGIN_LIST})
+  add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/windows plugins/${plugin})
+  target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin)
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
+endforeach(plugin)
+
+foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST})
+  add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin})
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries})
+endforeach(ffi_plugin)

apps/desktop/windows/runner/CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.14)
+project(runner LANGUAGES CXX)
+
+# Define the application target. To change its name, change BINARY_NAME in the
+# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer
+# work.
+#
+# Any new source files that you add to the application should be added here.
+add_executable(${BINARY_NAME} WIN32
+  "flutter_window.cpp"
+  "main.cpp"
+  "utils.cpp"
+  "win32_window.cpp"
+  "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
+  "Runner.rc"
+  "runner.exe.manifest"
+)
+
+# Apply the standard set of build settings. This can be removed for applications
+# that need different build settings.
+apply_standard_settings(${BINARY_NAME})
+
+# Add preprocessor definitions for the build version.
+target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION=\"${FLUTTER_VERSION}\"")
+target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}")
+target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}")
+target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}")
+target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}")
+
+# Disable Windows macros that collide with C++ standard library functions.
+target_compile_definitions(${BINARY_NAME} PRIVATE "NOMINMAX")
+
+# Add dependency libraries and include directories. Add any application-specific
+# dependencies here.
+target_link_libraries(${BINARY_NAME} PRIVATE flutter flutter_wrapper_app)
+target_link_libraries(${BINARY_NAME} PRIVATE "dwmapi.lib")
+target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}")
+
+# Run the Flutter tool portions of the build. This must not be removed.
+add_dependencies(${BINARY_NAME} flutter_assemble)

apps/desktop/windows/runner/Runner.rc

@@ -0,0 +1,121 @@
+// Microsoft Visual C++ generated resource script.
+//
+#pragma code_page(65001)
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (United States) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_APP_ICON            ICON                    "resources\\app_icon.ico"
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+#if defined(FLUTTER_VERSION_MAJOR) && defined(FLUTTER_VERSION_MINOR) && defined(FLUTTER_VERSION_PATCH) && defined(FLUTTER_VERSION_BUILD)
+#define VERSION_AS_NUMBER FLUTTER_VERSION_MAJOR,FLUTTER_VERSION_MINOR,FLUTTER_VERSION_PATCH,FLUTTER_VERSION_BUILD
+#else
+#define VERSION_AS_NUMBER 1,0,0,0
+#endif
+
+#if defined(FLUTTER_VERSION)
+#define VERSION_AS_STRING FLUTTER_VERSION
+#else
+#define VERSION_AS_STRING "1.0.0"
+#endif
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_AS_NUMBER
+ PRODUCTVERSION VERSION_AS_NUMBER
+ FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
+#ifdef _DEBUG
+ FILEFLAGS VS_FF_DEBUG
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS VOS__WINDOWS32
+ FILETYPE VFT_APP
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904e4"
+        BEGIN
+            VALUE "CompanyName", "com.example" "\0"
+            VALUE "FileDescription", "watch_together" "\0"
+            VALUE "FileVersion", VERSION_AS_STRING "\0"
+            VALUE "InternalName", "watch_together" "\0"
+            VALUE "LegalCopyright", "Copyright (C) 2026 com.example. All rights reserved." "\0"
+            VALUE "OriginalFilename", "watch_together.exe" "\0"
+            VALUE "ProductName", "watch_together" "\0"
+            VALUE "ProductVersion", VERSION_AS_STRING "\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1252
+    END
+END
+
+#endif    // English (United States) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED

apps/desktop/windows/runner/flutter_window.cpp

@@ -0,0 +1,71 @@
+#include "flutter_window.h"
+
+#include <optional>
+
+#include "flutter/generated_plugin_registrant.h"
+
+FlutterWindow::FlutterWindow(const flutter::DartProject& project)
+    : project_(project) {}
+
+FlutterWindow::~FlutterWindow() {}
+
+bool FlutterWindow::OnCreate() {
+  if (!Win32Window::OnCreate()) {
+    return false;
+  }
+
+  RECT frame = GetClientArea();
+
+  // The size here must match the window dimensions to avoid unnecessary surface
+  // creation / destruction in the startup path.
+  flutter_controller_ = std::make_unique<flutter::FlutterViewController>(
+      frame.right - frame.left, frame.bottom - frame.top, project_);
+  // Ensure that basic setup of the controller was successful.
+  if (!flutter_controller_->engine() || !flutter_controller_->view()) {
+    return false;
+  }
+  RegisterPlugins(flutter_controller_->engine());
+  SetChildContent(flutter_controller_->view()->GetNativeWindow());
+
+  flutter_controller_->engine()->SetNextFrameCallback([&]() {
+    this->Show();
+  });
+
+  // Flutter can complete the first frame before the "show window" callback is
+  // registered. The following call ensures a frame is pending to ensure the
+  // window is shown. It is a no-op if the first frame hasn't completed yet.
+  flutter_controller_->ForceRedraw();
+
+  return true;
+}
+
+void FlutterWindow::OnDestroy() {
+  if (flutter_controller_) {
+    flutter_controller_ = nullptr;
+  }
+
+  Win32Window::OnDestroy();
+}
+
+LRESULT
+FlutterWindow::MessageHandler(HWND hwnd, UINT const message,
+                              WPARAM const wparam,
+                              LPARAM const lparam) noexcept {
+  // Give Flutter, including plugins, an opportunity to handle window messages.
+  if (flutter_controller_) {
+    std::optional<LRESULT> result =
+        flutter_controller_->HandleTopLevelWindowProc(hwnd, message, wparam,
+                                                      lparam);
+    if (result) {
+      return *result;
+    }
+  }
+
+  switch (message) {
+    case WM_FONTCHANGE:
+      flutter_controller_->engine()->ReloadSystemFonts();
+      break;
+  }
+
+  return Win32Window::MessageHandler(hwnd, message, wparam, lparam);
+}

apps/desktop/windows/runner/flutter_window.h

@@ -0,0 +1,33 @@
+#ifndef RUNNER_FLUTTER_WINDOW_H_
+#define RUNNER_FLUTTER_WINDOW_H_
+
+#include <flutter/dart_project.h>
+#include <flutter/flutter_view_controller.h>
+
+#include <memory>
+
+#include "win32_window.h"
+
+// A window that does nothing but host a Flutter view.
+class FlutterWindow : public Win32Window {
+ public:
+  // Creates a new FlutterWindow hosting a Flutter view running |project|.
+  explicit FlutterWindow(const flutter::DartProject& project);
+  virtual ~FlutterWindow();
+
+ protected:
+  // Win32Window:
+  bool OnCreate() override;
+  void OnDestroy() override;
+  LRESULT MessageHandler(HWND window, UINT const message, WPARAM const wparam,
+                         LPARAM const lparam) noexcept override;
+
+ private:
+  // The project to run.
+  flutter::DartProject project_;
+
+  // The Flutter instance hosted by this window.
+  std::unique_ptr<flutter::FlutterViewController> flutter_controller_;
+};
+
+#endif  // RUNNER_FLUTTER_WINDOW_H_

apps/desktop/windows/runner/main.cpp

@@ -0,0 +1,43 @@
+#include <flutter/dart_project.h>
+#include <flutter/flutter_view_controller.h>
+#include <windows.h>
+
+#include "flutter_window.h"
+#include "utils.h"
+
+int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
+                      _In_ wchar_t *command_line, _In_ int show_command) {
+  // Attach to console when present (e.g., 'flutter run') or create a
+  // new console when running with a debugger.
+  if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) {
+    CreateAndAttachConsole();
+  }
+
+  // Initialize COM, so that it is available for use in the library and/or
+  // plugins.
+  ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+
+  flutter::DartProject project(L"data");
+
+  std::vector<std::string> command_line_arguments =
+      GetCommandLineArguments();
+
+  project.set_dart_entrypoint_arguments(std::move(command_line_arguments));
+
+  FlutterWindow window(project);
+  Win32Window::Point origin(10, 10);
+  Win32Window::Size size(1280, 720);
+  if (!window.Create(L"watch_together", origin, size)) {
+    return EXIT_FAILURE;
+  }
+  window.SetQuitOnClose(true);
+
+  ::MSG msg;
+  while (::GetMessage(&msg, nullptr, 0, 0)) {
+    ::TranslateMessage(&msg);
+    ::DispatchMessage(&msg);
+  }
+
+  ::CoUninitialize();
+  return EXIT_SUCCESS;
+}

apps/desktop/windows/runner/resource.h

@@ -0,0 +1,16 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by Runner.rc
+//
+#define IDI_APP_ICON                    101
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        102
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1001
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

apps/desktop/windows/runner/runner.exe.manifest

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
+    </windowsSettings>
+  </application>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- Windows 10 and Windows 11 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+    </application>
+  </compatibility>
+</assembly>

apps/desktop/windows/runner/utils.cpp

@@ -0,0 +1,69 @@
+#include "utils.h"
+
+#include <flutter_windows.h>
+#include <io.h>
+#include <stdio.h>
+#include <windows.h>
+
+#include <iostream>
+
+void CreateAndAttachConsole() {
+  if (::AllocConsole()) {
+    FILE *unused;
+    if (freopen_s(&unused, "CONOUT$", "w", stdout)) {
+      _dup2(_fileno(stdout), 1);
+    }
+    if (freopen_s(&unused, "CONOUT$", "w", stderr)) {
+      _dup2(_fileno(stdout), 2);
+    }
+    std::ios::sync_with_stdio();
+    FlutterDesktopResyncOutputStreams();
+  }
+}
+
+std::vector<std::string> GetCommandLineArguments() {
+  // Convert the UTF-16 command line arguments to UTF-8 for the Engine to use.
+  int argc;
+  wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
+  if (argv == nullptr) {
+    return std::vector<std::string>();
+  }
+
+  std::vector<std::string> command_line_arguments;
+
+  // Skip the first argument as it's the binary name.
+  for (int i = 1; i < argc; i++) {
+    command_line_arguments.push_back(Utf8FromUtf16(argv[i]));
+  }
+
+  ::LocalFree(argv);
+
+  return command_line_arguments;
+}
+
+std::string Utf8FromUtf16(const wchar_t* utf16_string) {
+  if (utf16_string == nullptr) {
+    return std::string();
+  }
+  // First, find the length of the string with a safe upper bound (CWE-126).
+  // UNICODE_STRING_MAX_CHARS (32767) is the maximum length of a UNICODE_STRING.
+  int input_length = static_cast<int>(wcsnlen(utf16_string, UNICODE_STRING_MAX_CHARS));
+  // Now use that bounded length to determine the required buffer size.
+  // When an explicit length is passed, WideCharToMultiByte does not include
+  // the null terminator in its returned size.
+  int target_length = ::WideCharToMultiByte(
+      CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string,
+      input_length, nullptr, 0, nullptr, nullptr);
+  std::string utf8_string;
+  if (target_length == 0 || static_cast<size_t>(target_length) > utf8_string.max_size()) {
+    return utf8_string;
+  }
+  utf8_string.resize(target_length);
+  int converted_length = ::WideCharToMultiByte(
+      CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string,
+      input_length, utf8_string.data(), target_length, nullptr, nullptr);
+  if (converted_length == 0) {
+    return std::string();
+  }
+  return utf8_string;
+}

apps/desktop/windows/runner/utils.h

@@ -0,0 +1,19 @@
+#ifndef RUNNER_UTILS_H_
+#define RUNNER_UTILS_H_
+
+#include <string>
+#include <vector>
+
+// Creates a console for the process, and redirects stdout and stderr to
+// it for both the runner and the Flutter library.
+void CreateAndAttachConsole();
+
+// Takes a null-terminated wchar_t* encoded in UTF-16 and returns a std::string
+// encoded in UTF-8. Returns an empty std::string on failure.
+std::string Utf8FromUtf16(const wchar_t* utf16_string);
+
+// Gets the command line arguments passed in as a std::vector<std::string>,
+// encoded in UTF-8. Returns an empty std::vector<std::string> on failure.
+std::vector<std::string> GetCommandLineArguments();
+
+#endif  // RUNNER_UTILS_H_

apps/desktop/windows/runner/win32_window.cpp

@@ -0,0 +1,288 @@
+#include "win32_window.h"
+
+#include <dwmapi.h>
+#include <flutter_windows.h>
+
+#include "resource.h"
+
+namespace {
+
+/// Window attribute that enables dark mode window decorations.
+///
+/// Redefined in case the developer's machine has a Windows SDK older than
+/// version 10.0.22000.0.
+/// See: https://docs.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute
+#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE
+#define DWMWA_USE_IMMERSIVE_DARK_MODE 20
+#endif
+
+constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW";
+
+/// Registry key for app theme preference.
+///
+/// A value of 0 indicates apps should use dark mode. A non-zero or missing
+/// value indicates apps should use light mode.
+constexpr const wchar_t kGetPreferredBrightnessRegKey[] =
+  L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize";
+constexpr const wchar_t kGetPreferredBrightnessRegValue[] = L"AppsUseLightTheme";
+
+// The number of Win32Window objects that currently exist.
+static int g_active_window_count = 0;
+
+using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd);
+
+// Scale helper to convert logical scaler values to physical using passed in
+// scale factor
+int Scale(int source, double scale_factor) {
+  return static_cast<int>(source * scale_factor);
+}
+
+// Dynamically loads the |EnableNonClientDpiScaling| from the User32 module.
+// This API is only needed for PerMonitor V1 awareness mode.
+void EnableFullDpiSupportIfAvailable(HWND hwnd) {
+  HMODULE user32_module = LoadLibraryA("User32.dll");
+  if (!user32_module) {
+    return;
+  }
+  auto enable_non_client_dpi_scaling =
+      reinterpret_cast<EnableNonClientDpiScaling*>(
+          GetProcAddress(user32_module, "EnableNonClientDpiScaling"));
+  if (enable_non_client_dpi_scaling != nullptr) {
+    enable_non_client_dpi_scaling(hwnd);
+  }
+  FreeLibrary(user32_module);
+}
+
+}  // namespace
+
+// Manages the Win32Window's window class registration.
+class WindowClassRegistrar {
+ public:
+  ~WindowClassRegistrar() = default;
+
+  // Returns the singleton registrar instance.
+  static WindowClassRegistrar* GetInstance() {
+    if (!instance_) {
+      instance_ = new WindowClassRegistrar();
+    }
+    return instance_;
+  }
+
+  // Returns the name of the window class, registering the class if it hasn't
+  // previously been registered.
+  const wchar_t* GetWindowClass();
+
+  // Unregisters the window class. Should only be called if there are no
+  // instances of the window.
+  void UnregisterWindowClass();
+
+ private:
+  WindowClassRegistrar() = default;
+
+  static WindowClassRegistrar* instance_;
+
+  bool class_registered_ = false;
+};
+
+WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr;
+
+const wchar_t* WindowClassRegistrar::GetWindowClass() {
+  if (!class_registered_) {
+    WNDCLASS window_class{};
+    window_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    window_class.lpszClassName = kWindowClassName;
+    window_class.style = CS_HREDRAW | CS_VREDRAW;
+    window_class.cbClsExtra = 0;
+    window_class.cbWndExtra = 0;
+    window_class.hInstance = GetModuleHandle(nullptr);
+    window_class.hIcon =
+        LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON));
+    window_class.hbrBackground = 0;
+    window_class.lpszMenuName = nullptr;
+    window_class.lpfnWndProc = Win32Window::WndProc;
+    RegisterClass(&window_class);
+    class_registered_ = true;
+  }
+  return kWindowClassName;
+}
+
+void WindowClassRegistrar::UnregisterWindowClass() {
+  UnregisterClass(kWindowClassName, nullptr);
+  class_registered_ = false;
+}
+
+Win32Window::Win32Window() {
+  ++g_active_window_count;
+}
+
+Win32Window::~Win32Window() {
+  --g_active_window_count;
+  Destroy();
+}
+
+bool Win32Window::Create(const std::wstring& title,
+                         const Point& origin,
+                         const Size& size) {
+  Destroy();
+
+  const wchar_t* window_class =
+      WindowClassRegistrar::GetInstance()->GetWindowClass();
+
+  const POINT target_point = {static_cast<LONG>(origin.x),
+                              static_cast<LONG>(origin.y)};
+  HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST);
+  UINT dpi = FlutterDesktopGetDpiForMonitor(monitor);
+  double scale_factor = dpi / 96.0;
+
+  HWND window = CreateWindow(
+      window_class, title.c_str(), WS_OVERLAPPEDWINDOW,
+      Scale(origin.x, scale_factor), Scale(origin.y, scale_factor),
+      Scale(size.width, scale_factor), Scale(size.height, scale_factor),
+      nullptr, nullptr, GetModuleHandle(nullptr), this);
+
+  if (!window) {
+    return false;
+  }
+
+  UpdateTheme(window);
+
+  return OnCreate();
+}
+
+bool Win32Window::Show() {
+  return ShowWindow(window_handle_, SW_SHOWNORMAL);
+}
+
+// static
+LRESULT CALLBACK Win32Window::WndProc(HWND const window,
+                                      UINT const message,
+                                      WPARAM const wparam,
+                                      LPARAM const lparam) noexcept {
+  if (message == WM_NCCREATE) {
+    auto window_struct = reinterpret_cast<CREATESTRUCT*>(lparam);
+    SetWindowLongPtr(window, GWLP_USERDATA,
+                     reinterpret_cast<LONG_PTR>(window_struct->lpCreateParams));
+
+    auto that = static_cast<Win32Window*>(window_struct->lpCreateParams);
+    EnableFullDpiSupportIfAvailable(window);
+    that->window_handle_ = window;
+  } else if (Win32Window* that = GetThisFromHandle(window)) {
+    return that->MessageHandler(window, message, wparam, lparam);
+  }
+
+  return DefWindowProc(window, message, wparam, lparam);
+}
+
+LRESULT
+Win32Window::MessageHandler(HWND hwnd,
+                            UINT const message,
+                            WPARAM const wparam,
+                            LPARAM const lparam) noexcept {
+  switch (message) {
+    case WM_DESTROY:
+      window_handle_ = nullptr;
+      Destroy();
+      if (quit_on_close_) {
+        PostQuitMessage(0);
+      }
+      return 0;
+
+    case WM_DPICHANGED: {
+      auto newRectSize = reinterpret_cast<RECT*>(lparam);
+      LONG newWidth = newRectSize->right - newRectSize->left;
+      LONG newHeight = newRectSize->bottom - newRectSize->top;
+
+      SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth,
+                   newHeight, SWP_NOZORDER | SWP_NOACTIVATE);
+
+      return 0;
+    }
+    case WM_SIZE: {
+      RECT rect = GetClientArea();
+      if (child_content_ != nullptr) {
+        // Size and position the child window.
+        MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left,
+                   rect.bottom - rect.top, TRUE);
+      }
+      return 0;
+    }
+
+    case WM_ACTIVATE:
+      if (child_content_ != nullptr) {
+        SetFocus(child_content_);
+      }
+      return 0;
+
+    case WM_DWMCOLORIZATIONCOLORCHANGED:
+      UpdateTheme(hwnd);
+      return 0;
+  }
+
+  return DefWindowProc(window_handle_, message, wparam, lparam);
+}
+
+void Win32Window::Destroy() {
+  OnDestroy();
+
+  if (window_handle_) {
+    DestroyWindow(window_handle_);
+    window_handle_ = nullptr;
+  }
+  if (g_active_window_count == 0) {
+    WindowClassRegistrar::GetInstance()->UnregisterWindowClass();
+  }
+}
+
+Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept {
+  return reinterpret_cast<Win32Window*>(
+      GetWindowLongPtr(window, GWLP_USERDATA));
+}
+
+void Win32Window::SetChildContent(HWND content) {
+  child_content_ = content;
+  SetParent(content, window_handle_);
+  RECT frame = GetClientArea();
+
+  MoveWindow(content, frame.left, frame.top, frame.right - frame.left,
+             frame.bottom - frame.top, true);
+
+  SetFocus(child_content_);
+}
+
+RECT Win32Window::GetClientArea() {
+  RECT frame;
+  GetClientRect(window_handle_, &frame);
+  return frame;
+}
+
+HWND Win32Window::GetHandle() {
+  return window_handle_;
+}
+
+void Win32Window::SetQuitOnClose(bool quit_on_close) {
+  quit_on_close_ = quit_on_close;
+}
+
+bool Win32Window::OnCreate() {
+  // No-op; provided for subclasses.
+  return true;
+}
+
+void Win32Window::OnDestroy() {
+  // No-op; provided for subclasses.
+}
+
+void Win32Window::UpdateTheme(HWND const window) {
+  DWORD light_mode;
+  DWORD light_mode_size = sizeof(light_mode);
+  LSTATUS result = RegGetValue(HKEY_CURRENT_USER, kGetPreferredBrightnessRegKey,
+                               kGetPreferredBrightnessRegValue,
+                               RRF_RT_REG_DWORD, nullptr, &light_mode,
+                               &light_mode_size);
+
+  if (result == ERROR_SUCCESS) {
+    BOOL enable_dark_mode = light_mode == 0;
+    DwmSetWindowAttribute(window, DWMWA_USE_IMMERSIVE_DARK_MODE,
+                          &enable_dark_mode, sizeof(enable_dark_mode));
+  }
+}

apps/desktop/windows/runner/win32_window.h

@@ -0,0 +1,102 @@
+#ifndef RUNNER_WIN32_WINDOW_H_
+#define RUNNER_WIN32_WINDOW_H_
+
+#include <windows.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+// A class abstraction for a high DPI-aware Win32 Window. Intended to be
+// inherited from by classes that wish to specialize with custom
+// rendering and input handling
+class Win32Window {
+ public:
+  struct Point {
+    unsigned int x;
+    unsigned int y;
+    Point(unsigned int x, unsigned int y) : x(x), y(y) {}
+  };
+
+  struct Size {
+    unsigned int width;
+    unsigned int height;
+    Size(unsigned int width, unsigned int height)
+        : width(width), height(height) {}
+  };
+
+  Win32Window();
+  virtual ~Win32Window();
+
+  // Creates a win32 window with |title| that is positioned and sized using
+  // |origin| and |size|. New windows are created on the default monitor. Window
+  // sizes are specified to the OS in physical pixels, hence to ensure a
+  // consistent size this function will scale the inputted width and height as
+  // as appropriate for the default monitor. The window is invisible until
+  // |Show| is called. Returns true if the window was created successfully.
+  bool Create(const std::wstring& title, const Point& origin, const Size& size);
+
+  // Show the current window. Returns true if the window was successfully shown.
+  bool Show();
+
+  // Release OS resources associated with window.
+  void Destroy();
+
+  // Inserts |content| into the window tree.
+  void SetChildContent(HWND content);
+
+  // Returns the backing Window handle to enable clients to set icon and other
+  // window properties. Returns nullptr if the window has been destroyed.
+  HWND GetHandle();
+
+  // If true, closing this window will quit the application.
+  void SetQuitOnClose(bool quit_on_close);
+
+  // Return a RECT representing the bounds of the current client area.
+  RECT GetClientArea();
+
+ protected:
+  // Processes and route salient window messages for mouse handling,
+  // size change and DPI. Delegates handling of these to member overloads that
+  // inheriting classes can handle.
+  virtual LRESULT MessageHandler(HWND window,
+                                 UINT const message,
+                                 WPARAM const wparam,
+                                 LPARAM const lparam) noexcept;
+
+  // Called when CreateAndShow is called, allowing subclass window-related
+  // setup. Subclasses should return false if setup fails.
+  virtual bool OnCreate();
+
+  // Called when Destroy is called.
+  virtual void OnDestroy();
+
+ private:
+  friend class WindowClassRegistrar;
+
+  // OS callback called by message pump. Handles the WM_NCCREATE message which
+  // is passed when the non-client area is being created and enables automatic
+  // non-client DPI scaling so that the non-client area automatically
+  // responds to changes in DPI. All other messages are handled by
+  // MessageHandler.
+  static LRESULT CALLBACK WndProc(HWND const window,
+                                  UINT const message,
+                                  WPARAM const wparam,
+                                  LPARAM const lparam) noexcept;
+
+  // Retrieves a class instance pointer for |window|
+  static Win32Window* GetThisFromHandle(HWND const window) noexcept;
+
+  // Update the window frame's theme to match the system theme.
+  static void UpdateTheme(HWND const window);
+
+  bool quit_on_close_ = false;
+
+  // window handle for top level window.
+  HWND window_handle_ = nullptr;
+
+  // window handle for hosted content.
+  HWND child_content_ = nullptr;
+};
+
+#endif  // RUNNER_WIN32_WINDOW_H_