redis
diff --git a/‎docs/sentinel.md‎
Lines changed: 26 additions & 0 deletions b/‎docs/sentinel.md‎
Lines changed: 26 additions & 0 deletions
diff --git a/‎packages/client/lib/client/index.spec.ts‎
Lines changed: 14 additions & 0 deletions b/‎packages/client/lib/client/index.spec.ts‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎packages/client/lib/client/index.ts‎
Lines changed: 11 additions & 0 deletions b/‎packages/client/lib/client/index.ts‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎packages/client/lib/client/socket.ts‎
Lines changed: 10 additions & 7 deletions b/‎packages/client/lib/client/socket.ts‎
Lines changed: 10 additions & 7 deletions
diff --git a/‎packages/client/lib/sentinel/index.spec.ts‎
Lines changed: 27 additions & 0 deletions b/‎packages/client/lib/sentinel/index.spec.ts‎
Lines changed: 27 additions & 0 deletions
@@ -85,6 +85,32 @@ const sentinel = await createSentinel({
 | passthroughClientErrorEvents | `false` | When `true`, error events from client instances inside the sentinel will be propagated to the sentinel instance. This allows handling all client errors through a single error handler on the sentinel instance.                                                                                                     |
 | reserveClient              | `false`   | When `true`, one client will be reserved for the sentinel object. When `false`, the sentinel object will wait for the first available client from the pool.                                                                                                                                                           |
 
+## Events
+
+The sentinel object is an `EventEmitter` and emits the following lifecycle events, tracking its own `isOpen`/`isReady` state (see [`client.isReady`](../README.md#events) for the standalone client equivalents):
+
+| Name           | When                                                                                                | Listener arguments |
+| -------------- | --------------------------------------------------------------------------------------------------- | ------------------ |
+| `connect`      | The sentinel starts opening a connection (`isOpen` becomes `true`)                                  | _No arguments_     |
+| `ready`        | The sentinel has discovered the topology and is ready to accept commands (`isReady` becomes `true`) | _No arguments_     |
+| `reconnecting` | The monitored master actually changed, so the sentinel is reconfiguring and momentarily not ready (`isReady` becomes `false`). Not emitted for routine topology scans that change nothing. | _No arguments_     |
+| `end`          | The connection has been closed via `close()` or `destroy()` (`isOpen` becomes `false`)              | _No arguments_     |
+| `error`        | An error on the sentinel itself (e.g. topology discovery failed, or a `ready`/`reconnecting` listener threw). Errors from the underlying master/replica/sentinel clients are included here **only when** [`passthroughClientErrorEvents: true`](#createsentinel-configuration); otherwise they are not surfaced on the sentinel object. May be a formatted string rather than an `Error`. | `(error: Error \| string)` |
+| `topology-change` | The monitored topology changed (master/replica added, removed, or promoted)                      | `(event: RedisSentinelEvent)` |
+
+```javascript
+sentinel
+  .on('connect', () => console.log('sentinel connecting'))
+  .on('ready', () => console.log('sentinel ready'))
+  .on('reconnecting', () => console.log('sentinel reconfiguring after a topology change'))
+  .on('end', () => console.log('sentinel closed'))
+  .on('error', err => console.error('Redis Sentinel Error', err));
+```
+
+> :warning: You **MUST** listen to `error` events. Without at least one `error` listener, an emitted error is thrown and crashes the process.
+
+**Divergence from the standalone client:** these events track the sentinel facade's own state, not the sockets of the individual master/replica node clients. `reconnecting` is emitted only when the monitored master actually changes (a failover) — routine periodic topology scans that find no change are silent — and `ready` is re-emitted once the new master is connected; the per-socket reconnect churn of the underlying node clients is not surfaced. Because the sentinel abstracts failover away, a `connect`/`ready` pair is emitted once on the initial `connect()`, and `end` fires at most once even if `close()` and `destroy()` are both called. Also note that `connect` marks the start of the connection attempt (not an established socket), so a `connect()` that fails emits `connect` followed by `end` before rejecting — whereas the standalone client emits `connect` only once the socket is established: a standalone `connect()` that never reaches the server emits nothing, though it still emits `connect` before rejecting when the socket connects but initialization (e.g. authentication) fails afterwards.
+
 ## Reconnecting after an outage
 
 As the client learns the sentinel topology it discovers additional sentinel nodes (reported by the sentinels as IP addresses). The nodes you pass in `sentinelRootNodes` are kept as **seeds**: they are always retained as reconnection candidates and are tried first, alongside the discovered nodes. This matters after an outage where the whole sentinel set restarts.
 
@@ -1698,6 +1698,20 @@ describe('Client', () => {
 
       server.close();
     });
+
+    // A blocking command keeps the queue from draining, so close() waits; a concurrent
+    // destroy() force-kills the socket, and close() must settle instead of hanging forever
+    // on a `data` event a destroyed socket never delivers.
+    testUtils.testWithClient('settles when a concurrent destroy() force-kills the draining socket', async client => {
+      const blocked = client.blPop('close-destroy-block-key', 0).then(() => 'resolved', () => 'rejected');
+      await new Promise<void>(resolve => { globalThis.setTimeout(resolve, 50); }); // let BLPOP reach the wire
+
+      const closing = client.close();
+      client.destroy();
+
+      await closing; // hangs (test times out) if close() never settles
+      assert.equal(await blocked, 'rejected');
+    }, GLOBAL.SERVERS.OPEN);
   });
 });
 
 
@@ -2206,15 +2206,26 @@ export default class RedisClient<
         return resolve();
       }
 
+      // A concurrent destroy() can force-kill the draining socket; it tears the socket down
+      // itself and emits `end`, so settle then too — otherwise we would wait forever for a
+      // `data` event that a destroyed socket never delivers, leaking this promise and its
+      // listeners.
+      const onEnd = () => {
+        this._self.#socket.off('data', maybeClose);
+        this._self.#unregisterFromMetrics();
+        resolve();
+      };
       const maybeClose = () => {
         if (!this._self.#queue.isEmpty()) return;
 
         this._self.#socket.off('data', maybeClose);
+        this._self.#socket.off('end', onEnd);
         this._self.#unregisterFromMetrics();
         this._self.#socket.destroySocket();
         resolve();
       };
       this._self.#socket.on('data', maybeClose);
+      this._self.#socket.once('end', onEnd);
     });
   }
 
 
@@ -485,13 +485,16 @@ export default class RedisSocket extends EventEmitter {
   }
 
   destroy() {
-    // Idempotent: return instead of throwing when already closed. A terminal
-    // connect failure (reconnectStrategy gave up) leaves #isOpen === false, and
-    // the owning client still needs to dispose itself (unregister metrics,
-    // dispose credentials) — throwing here would abort that cleanup. Returning
-    // also means a repeated destroy() won't re-run destroySocket() and
-    // republish CONNECTION_CLOSED / re-emit 'end'.
-    if (!this.#isOpen) return;
+    // Idempotent: return instead of throwing when there is nothing left to tear down.
+    // A terminal connect failure (reconnectStrategy gave up) leaves #isOpen === false, and
+    // the owning client still needs to dispose itself (unregister metrics, dispose
+    // credentials) — throwing here would abort that cleanup. Returning also means a
+    // repeated destroy() won't re-run destroySocket() and republish CONNECTION_CLOSED /
+    // re-emit 'end'. But a graceful close() also leaves #isOpen === false while keeping the
+    // socket alive to drain, so key the guard on the socket too: while one remains, destroy()
+    // must still force-terminate it (e.g. when a caller escalates close() to destroy()).
+    if (!this.#isOpen && !this.#socket) return;
+
     this.#isOpen = false;
     this.destroySocket();
   }
 
@@ -966,6 +966,33 @@ describe('legacy tests', () => {
       assert.notEqual(masterNode!.port, newMaster.port);
     });
 
+    // a failover drops readiness while reconfiguring (emits `reconnecting`) and
+    // restores it once the new topology is connected (re-emits `ready`)
+    it('emits reconnecting then ready across a failover', async function () {
+      this.timeout(60000);
+
+      sentinel = frame.getSentinelClient();
+      sentinel.setTracer(tracer);
+      sentinel.on('error', () => { });
+      await sentinel.connect();
+
+      let sawReconnecting = false;
+      let readyAfterReconnectResolve: () => void;
+      const readyAfterReconnect = new Promise<void>(res => { readyAfterReconnectResolve = res; });
+      sentinel
+        .on('reconnecting', () => { sawReconnecting = true; })
+        .on('ready', () => { if (sawReconnecting) readyAfterReconnectResolve(); });
+
+      const masterNode = sentinel.getMasterNode();
+      tracer.push(`stopping master node`);
+      await frame.stopNode(masterNode!.port.toString());
+
+      // resolves only after a `reconnecting` followed by a `ready`; otherwise the
+      // test times out, which is the failure signal we want
+      await readyAfterReconnect;
+      assert.ok(sawReconnecting);
+    });
+
     // if master changes, client should make sure user knows watches are invalid
     it('watch across master change', async function () {
       this.timeout(60000);