fix: address post-review issues in SignalingModule and IsolateManager

- isolate_manager: fix connectivityNoneCounter reset — error now fires
  exactly once at maxConnectivityNoneRepeats; subsequent none-events are
  silently ignored until connectivity is restored and counter resets to 0

- main_shell: split SignalingModule construction into valid/invalid-creds
  branches to remove ?? '' fallbacks and make intent explicit

- signaling_module: document sync:true reentrancy assumption, single-use
  constraint on events getter, and _errorHandled ordering invariant

Author: SERDUN

lib/app/router/main_shell.dart

@@ -84,18 +84,25 @@ class _MainShellState extends State<MainShell> with WidgetsBindingObserver {
     final session = context.read<AppBloc>().state.session;
     final coreUrl = session.coreUrl;
     final token = session.token;
-    _signalingModule = SignalingModule(
-      coreUrl: coreUrl ?? '',
-      tenantId: session.tenantId,
-      token: token ?? '',
-      trustedCertificates: context.read<AppCertificates>().trustedCertificates,
-      signalingClientFactory: defaultSignalingClientFactory,
-    );
     if (coreUrl == null || token == null) {
+      _signalingModule = SignalingModule(
+        coreUrl: '',
+        tenantId: session.tenantId,
+        token: '',
+        trustedCertificates: context.read<AppCertificates>().trustedCertificates,
+        signalingClientFactory: defaultSignalingClientFactory,
+      );
       WidgetsBinding.instance.addPostFrameCallback((_) {
         context.read<AppBloc>().add(const AppLogoutRequested(reason: AppLogoutReason.sessionMissed));
       });
     } else {
+      _signalingModule = SignalingModule(
+        coreUrl: coreUrl,
+        tenantId: session.tenantId,
+        token: token,
+        trustedCertificates: context.read<AppCertificates>().trustedCertificates,
+        signalingClientFactory: defaultSignalingClientFactory,
+      );
       _signalingModule.connect();
     }
 

lib/features/call/services/isolate_manager.dart

@@ -128,9 +128,10 @@ abstract class IsolateManager implements CallkeepBackgroundServiceDelegate {
         logger.warning('No internet connection detected ($connectivityNoneCounter/$maxConnectivityNoneRepeats)');
 
         if (connectivityNoneCounter >= maxConnectivityNoneRepeats) {
-          logger.severe('Max connectivity loss reached');
-          _onSignalingError('Max connectivity loss reached');
-          connectivityNoneCounter = 0;
+          if (connectivityNoneCounter == maxConnectivityNoneRepeats) {
+            logger.severe('Max connectivity loss reached');
+            _onSignalingError('Max connectivity loss reached');
+          }
           return;
         }
 

lib/features/call/services/signaling_module.dart

@@ -98,6 +98,12 @@ class SignalingModule {
   // sync: true ensures events are delivered to existing listeners in the same
   // call stack as _emit(), preserving ordering and eliminating async-dispatch
   // races where a late-arriving broadcast event could duplicate a replayed one.
+  //
+  // Reentrancy assumption: consumers must not call connect() or disconnect()
+  // synchronously inside an event listener. Doing so would re-enter _emit()
+  // in the same stack frame and produce unexpected ordering. All current
+  // consumers (CallBloc.add(), IsolateManager timer callbacks) satisfy this —
+  // they either queue events or schedule via Timer, never calling back directly.
   final _controller = StreamController<SignalingModuleEvent>.broadcast(sync: true);
 
   /// Events buffered since the last [connect] call. Cleared on every [connect]
@@ -123,6 +129,13 @@ class SignalingModule {
   /// (which fires when the underlying socket closes after an error) is
   /// suppressed — [_onError] already emits [SignalingConnectionFailed] and
   /// consumers would otherwise receive two separate reconnect triggers.
+  ///
+  /// Ordering invariant: [_onDisconnect] for the failed socket always arrives
+  /// before any reconnect-triggered [_connectAsync] completes, because reconnect
+  /// is scheduled via [kSignalingClientReconnectDelay] (several seconds) while
+  /// the socket close-ack is delivered in the current event loop iteration.
+  /// [_onDisconnect] resets this flag to false, so a newly connected client
+  /// starts with a clean state.
   bool _errorHandled = false;
 
   /// Last connect error as string for deduplication.
@@ -138,6 +151,13 @@ class SignalingModule {
   ///
   /// Note: [SignalingProtocolEvent] (call events) are NOT replayed — they are
   /// only delivered to subscribers already listening when they occur.
+  ///
+  /// Each call to [events] creates a new independent stream backed by a
+  /// dedicated [StreamController] and a live subscription to the internal
+  /// broadcast controller. Call [events] exactly once per consumer and hold
+  /// the returned [StreamSubscription] for the consumer's lifetime; calling
+  /// it multiple times without cancelling previous subscriptions leaks
+  /// controllers.
   Stream<SignalingModuleEvent> get events {
     // Take a snapshot of the buffer BEFORE subscribing to the live stream so
     // that any event arriving between snapshot and subscribe is delivered only