perf: signal readiness before running post-connect initialization work

handleAllConnected previously did its post-connect initialization work
(auto-discover networks, queue initial getall, set up periodic timers,
construct + trigger HA Discovery) and THEN signaled readiness at the end.
The auto-discovery step alone can take up to 5s (it has a 5s timeout
waiting for the tree command response). So users with autoDiscoverNetworks
enabled (the default) saw a 5s gap between connections coming up and the
bridge advertising itself as ready, even though all the connection-level
prerequisites were already satisfied.

Moves the readiness signal to fire as soon as connection health is
confirmed. The rest of the post-connect work runs after, in the same
async chain - the production caller (cgateWebBridge#_handleAllConnected)
already doesn't await this function, so the work proceeds in the
background. Tests still await the function and observe all work
completing.

Net: ~up-to-5s faster ready-signal-to-wire latency for users with
auto-discovery; no behaviour change for the work itself or its ordering
within the function. Regression test asserts readiness fires before
both the command-queue add and the discovery trigger.

Author: dougrathbone

src/bridgeInitializationService.js

@@ -23,6 +23,16 @@ class BridgeInitializationService {
         this.bridge._lastInitTime = now;
         this.bridge.log('ALL CONNECTED - Initializing services...');
 
+        // Signal readiness up-front. All connection-health checks have already
+        // passed by the time this handler fires, and the post-connect work
+        // below (auto-discover, initial getall, HA Discovery TreeXML sweep) is
+        // initialization that doesn't gate the bridge's ability to serve. The
+        // production caller does not await this function, so moving the signal
+        // up lets the readiness MQTT publish land on the wire before the
+        // (potentially 5s) auto-discovery wait. Tests that await the function
+        // still observe all work completing as before.
+        this.bridge._updateBridgeReadiness('all-connected');
+
         // Auto-discover networks from C-Gate if enabled and no explicit config overrides it
         if (this.bridge.settings.autoDiscoverNetworks) {
             await this._discoverNetworks();
@@ -65,7 +75,6 @@ class BridgeInitializationService {
             this.bridge.haDiscovery.trigger(this.bridge.discoveredNetworks || null);
         }
 
-        this.bridge._updateBridgeReadiness('all-connected');
         this._logStartupSummary();
     }
 

tests/bridgeInitializationService.test.js

@@ -427,6 +427,35 @@ describe('BridgeInitializationService', () => {
             expect(bridge._updateBridgeReadiness).toHaveBeenCalledWith('all-connected');
         });
 
+        it('signals readiness BEFORE running the post-connect init work', async () => {
+            // The whole point of the v1.9.1 deferral: readiness MUST publish
+            // before any of the post-connect work (auto-discovery wait,
+            // initial getall queue, HA Discovery trigger). Capture the call
+            // order across the readiness signal, the command-queue add, and
+            // the haDiscovery construction.
+            const { bridge, commandQueueAdd } = makeBridge({
+                ha_discovery_enabled: true,
+                getallonstart: true,
+                getall_networks: [254]
+            });
+
+            const eventOrder = [];
+            bridge._updateBridgeReadiness = jest.fn(() => eventOrder.push('readiness'));
+            commandQueueAdd.mockImplementation(() => eventOrder.push('queue-add'));
+            HaDiscovery.mockImplementation(() => {
+                eventOrder.push('discovery-ctor');
+                return { trigger: jest.fn(() => eventOrder.push('discovery-trigger')) };
+            });
+
+            const svc = new BridgeInitializationService(bridge);
+            await svc.handleAllConnected();
+
+            // readiness fires first - then the rest of the post-connect work.
+            expect(eventOrder[0]).toBe('readiness');
+            expect(eventOrder).toContain('queue-add');
+            expect(eventOrder).toContain('discovery-trigger');
+        });
+
         it('passes working publish callback to HaDiscovery', async () => {
             const { bridge, mqttPublish } = makeBridge({ ha_discovery_enabled: true });
             const svc = new BridgeInitializationService(bridge);