Server on an isolate, dedicated server binary, room -> server (proto 5)

- serve(Map config, events) is the one server entrypoint: the app
  hosts it via Isolate.spawn (crash surfaced on the Host card, logs
  forwarded as [server]); bin/server.dart is the dedicated server,
  compiled into the bundle as watch-together-server. --headless gone.
- Host identity via a per-hosting hostKey in hello, replacing the
  loopback heuristic.
- Rename room -> server across code, files and wire (t:"state",
  /health name); protocol bumped to 5.
- CI compiles the server binary; isolate smoke tests in server and
  desktop suites. Docs updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

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

@@ -0,0 +1,148 @@
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:flutter/foundation.dart' show visibleForTesting;
+import 'package:sync_relay_core/core.dart';
+import 'package:sync_relay_server/server.dart';
+
+Future<void> _serverMain((Map<String, Object?>, SendPort) args) =>
+    serve(args.$1, events: args.$2);
+
+/// The hosted server, running [serve] on its own isolate. Its log lines
+/// go to [onLog]; if the isolate dies without being asked to stop,
+/// [onCrash] gets the cause once.
+class ServerIsolate {
+  final Isolate _isolate;
+  final SendPort _stop;
+  final int port;
+  final ReceivePort _events;
+  final ReceivePort _errors;
+  final ReceivePort _exit;
+  final Completer<void> _exited = Completer<void>();
+  bool _stopping = false;
+  String? _lastError;
+  void Function(String error)? _onCrash;
+
+  ServerIsolate._(this._isolate, this._stop, this.port, this._events,
+      this._errors, this._exit);
+
+  @visibleForTesting
+  Isolate get isolate => _isolate;
+
+  bool get isRunning => !_exited.isCompleted;
+
+  /// Spawns the server and waits until it listens. Throws a
+  /// [StateError] with the server's message if it cannot start.
+  static Future<ServerIsolate> start(
+    AppConfig config, {
+    required void Function(String line) onLog,
+    required void Function(String error) onCrash,
+    Duration timeout = const Duration(seconds: 15),
+  }) async {
+    final events = ReceivePort('server events');
+    final errors = ReceivePort('server errors');
+    final exit = ReceivePort('server exit');
+    final startup = Completer<(int, SendPort)>();
+    String? lastError;
+    var exited = false;
+    ServerIsolate? self;
+
+    void fail(String message) {
+      if (!startup.isCompleted) startup.completeError(StateError(message));
+    }
+
+    events.listen((msg) {
+      if (msg is! Map) return;
+      switch (msg['t']) {
+        case 'log':
+          final err = msg['error'];
+          onLog('${msg['level']} ${msg['logger']}: ${msg['message']}'
+              '${err == null ? '' : ' ($err)'}');
+        case 'ready':
+          if (!startup.isCompleted) {
+            startup.complete((msg['port'] as int, msg['stop'] as SendPort));
+          }
+        case 'error':
+          fail('${msg['message']}');
+      }
+    });
+    // errorsAreFatal is off: a stray async error is logged and the server
+    // keeps going, as it did in-process. Only a dead isolate is a crash.
+    errors.listen((msg) {
+      final text = msg is List && msg.isNotEmpty ? '${msg.first}' : '$msg';
+      lastError = text;
+      self?._lastError = text;
+      onLog('SEVERE uncaught: $text');
+    });
+    exit.listen((_) {
+      exited = true;
+      fail(lastError ?? 'server exited before it was ready');
+      self?._onExit();
+    });
+
+    final Isolate isolate;
+    try {
+      isolate = await Isolate.spawn(
+          _serverMain, (config.toMap(), events.sendPort),
+          errorsAreFatal: false,
+          onError: errors.sendPort,
+          onExit: exit.sendPort,
+          debugName: 'server');
+    } catch (_) {
+      events.close();
+      errors.close();
+      exit.close();
+      rethrow;
+    }
+    final (int, SendPort) ready;
+    try {
+      ready = await startup.future.timeout(timeout);
+    } catch (e) {
+      if (!exited) isolate.kill(priority: Isolate.immediate);
+      events.close();
+      errors.close();
+      exit.close();
+      if (e is TimeoutException) {
+        throw StateError('server did not start within ${timeout.inSeconds} s');
+      }
+      rethrow;
+    }
+    final s = ServerIsolate._(isolate, ready.$2, ready.$1, events, errors, exit)
+      .._onCrash = onCrash
+      .._lastError = lastError;
+    self = s;
+    if (exited) {
+      // Died between ready and here: a failed start, not a crash.
+      s._stopping = true;
+      s._onExit();
+      throw StateError(lastError ?? 'server exited right after starting');
+    }
+    return s;
+  }
+
+  void _onExit() {
+    if (_exited.isCompleted) return;
+    _exited.complete();
+    _events.close();
+    _errors.close();
+    _exit.close();
+    final crash = _onCrash;
+    _onCrash = null;
+    if (!_stopping) crash?.call(_lastError ?? 'the server stopped unexpectedly');
+  }
+
+  /// Asks the server to close its sockets and exit; kills the isolate if it
+  /// has not exited within [timeout].
+  Future<void> stop({Duration timeout = const Duration(seconds: 3)}) async {
+    if (_exited.isCompleted) return;
+    _stopping = true;
+    _stop.send({'t': 'stop'});
+    try {
+      await _exited.future.timeout(timeout);
+    } on TimeoutException {
+      _isolate.kill(priority: Isolate.immediate);
+      await _exited.future.timeout(const Duration(seconds: 2),
+          onTimeout: _onExit);
+    }
+  }
+}

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

@@ -1,16 +1,17 @@
 import 'dart:async';
 import 'dart:convert';
+import 'dart:math';
 
 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';
+import 'server_isolate.dart';
 
 enum AppRoute {
   home,
@@ -128,6 +129,21 @@ List<RecentServer> migrateRecents(
   return [RecentServer(hosted: false, host: host.trim(), port: port, secret: secret)];
 }
 
+/// The hosted server died during setup; shown on the Host card.
+class ServerCrashed implements Exception {
+  final String cause;
+  const ServerCrashed(this.cause);
+  @override
+  String toString() => 'server crashed: $cause';
+}
+
+/// A fresh per-hosting key: the app's own client sends it in hello to be
+/// recognised as the (unkickable) host.
+String newHostKey() {
+  final r = Random.secure();
+  return base64Url.encode([for (var i = 0; i < 24; i++) r.nextInt(256)]);
+}
+
 class SessionState {
   static final SessionState instance = SessionState._();
   SessionState._();
@@ -135,11 +151,17 @@ class SessionState {
   final route = signal(AppRoute.home);
   final recents = signal<List<RecentServer>>(const []);
   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;
+  /// Set when the hosted server died mid-session; Home shows it on the
+  /// Host card and clears it.
+  final serverCrash = signal<String?>(null);
+  ServerIsolate? _server;
+  String? _setupCrash;
+
+  @visibleForTesting
+  ServerIsolate? get hostedServer => _server;
   void Function()? _stopKickWatch;
   // Bumped by host/join/cancelPending: a cancelled setup notices at its
   // next step and unwinds instead of connecting.
@@ -208,18 +230,25 @@ class SessionState {
           const HealthStatus(HealthSeverity.info, 'starting server…');
       await stopServer();
       if (op != _op) throw const ConnectCancelled();
-      final server = RoomServer(AppConfig(
-        port: params.port,
-        secret: params.secret,
-        name: 'room',
-        mediaPath: params.mediaPath,
-      ));
+      final hostKey = newHostKey();
+      _setupCrash = null;
+      late final ServerIsolate server;
       try {
-        await server.start();
+        server = await ServerIsolate.start(
+          AppConfig(
+            port: params.port,
+            secret: params.secret,
+            name: 'server',
+            mediaPath: params.mediaPath,
+            hostKey: hostKey,
+          ),
+          onLog: (line) => debugPrint('[server] $line'),
+          onCrash: (cause) => _onServerCrash(server, cause),
+        );
       } catch (e, st) {
         debugPrint('server start failed: $e\n$st');
         status.value = HealthStatus(
-            HealthSeverity.error, 'cannot bind port ${params.port}: $e');
+            HealthSeverity.error, 'cannot start server on port ${params.port}: $e');
         rethrow;
       }
       if (op != _op) {
@@ -228,20 +257,23 @@ class SessionState {
       }
       _server = server;
       status.value =
-          HealthStatus(HealthSeverity.ok, 'hosting on port ${server.boundPort}');
+          HealthStatus(HealthSeverity.ok, 'hosting on port ${server.port}');
       try {
         await coordinator.connect(ConnectParams(
           host: '127.0.0.1',
-          port: server.boundPort,
+          port: server.port,
           secret: params.secret,
           name: params.name,
           avatar: params.avatar,
           linkUrl: params.linkUrl,
+          hostKey: hostKey,
         ));
         if (op != _op) throw const ConnectCancelled();
-      } catch (_) {
+      } catch (e) {
         // Own join failed or was cancelled: don't leave the port open.
         if (identical(_server, server)) await stopServer();
+        final crash = _setupCrash;
+        if (crash != null && e is! ConnectCancelled) throw ServerCrashed(crash);
         rethrow;
       }
       _watchKick();
@@ -251,6 +283,21 @@ class SessionState {
     }
   }
 
+  /// The server isolate died without being stopped. In a session: show it
+  /// and leave. During setup the own join fails and [host] reports it.
+  void _onServerCrash(ServerIsolate server, String cause) {
+    if (!identical(_server, server)) return;
+    final message = 'server crashed: $cause';
+    debugPrint('[server] $message');
+    if (route.peek() != AppRoute.session) {
+      _setupCrash = cause;
+      return;
+    }
+    coordinator.health.value = HealthStatus(HealthSeverity.error, message);
+    serverCrash.value = message;
+    unawaited(leave().catchError((Object e) => debugPrint('leave after crash failed: $e')));
+  }
+
   Future<void> join(ConnectParams params, ConnectForm form) async {
     final op = ++_op;
     _rememberForm(form);
@@ -305,15 +352,6 @@ class SessionState {
       ..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: '', name: 'room'));
-    await _server!.start();
-  }
-
   Future<void> stopServer() async {
     _stopKickWatch?.call();
     _stopKickWatch = null;