@noverachat/sdk-web 0.5.1 → 0.5.3

package/dist/index.cjs

@@ -403,14 +403,26 @@ var ReconnectingWs = class _ReconnectingWs {
   // heartbeats and a stale typing event is worse than no event.
   outboundQueue = [];
   static OUTBOUND_QUEUE_CAP = 200;
+  /**
+   * 연결 시도의 세대 번호 — `connect()`/`close()` 마다 올린다.
+   *
+   * `openOnce()` 는 `urlBuilder()`(토큰 발급 왕복)를 await 하는 동안 아직
+   * 소켓이 없어서, 그 틈에 들어온 `close()` 는 닫을 대상을 찾지 못한다.
+   * 이어서 새 `connect()` 가 `explicitClose` 를 되돌리면, 뒤늦게 깨어난
+   * 앞선 시도가 **아무도 닫지 않는 소켓**을 하나 더 만든다(React StrictMode 의
+   * mount → cleanup → mount 에서 재현). 불리언 하나로는 "이미 취소됐다"를
+   * 알릴 수 없으므로 세대 번호로 판별한다.
+   */
+  gen = 0;
   get currentState() {
     return this.state;
   }
   async connect() {
     this.explicitClose = false;
-    await this.openOnce();
+    await this.openOnce(++this.gen);
   }
   close() {
+    this.gen++;
     this.explicitClose = true;
     this.setState("closed");
     if (this.pingTimer) clearInterval(this.pingTimer);
@@ -443,7 +455,8 @@ var ReconnectingWs = class _ReconnectingWs {
     );
     return true;
   }
-  async openOnce() {
+  async openOnce(gen) {
+    if (gen !== this.gen) return;
     this.setState(this.attempt === 0 ? "connecting" : "reconnecting");
     const WSImpl = this.opts.WebSocketImpl ?? globalThis.WebSocket;
     if (!WSImpl) throw new Error("No WebSocket implementation available");
@@ -452,7 +465,11 @@ var ReconnectingWs = class _ReconnectingWs {
       url = await this.opts.urlBuilder();
     } catch (err) {
       this.opts.logger?.("error", "url_builder_failed", err);
-      this.scheduleReconnect();
+      if (gen === this.gen) this.scheduleReconnect();
+      return;
+    }
+    if (gen !== this.gen) {
+      this.opts.logger?.("info", "ws_open_aborted_stale", { gen, current: this.gen });
       return;
     }
     const ws = new WSImpl(url);
@@ -517,8 +534,9 @@ var ReconnectingWs = class _ReconnectingWs {
     const delay = exp + jitter;
     this.opts.logger?.("info", "ws_reconnect_scheduled", { attempt: this.attempt, delay });
     this.setState("reconnecting");
+    const gen = this.gen;
     setTimeout(() => {
-      void this.openOnce();
+      void this.openOnce(gen);
     }, delay);
   }
   startPings() {
@@ -2048,6 +2066,16 @@ var Room = class _Room {
     this.pendingAcks.delete(tempId2);
     this.mySentTempIds.delete(tempId2);
   }
+  /**
+   * ack 를 기다리던 전송을 전부 실패 처리한다 — `chat.disconnect()` 처럼
+   * 응답이 올 길이 사라졌을 때. 메시지 컬렉션은 건드리지 않는다(낙관적
+   * 버블은 `failed` 로 바뀌어 재전송 UI 를 띄울 수 있다).
+   */
+  _failPendingSends(reason) {
+    for (const tempId2 of [...this.pendingAcks.keys()]) {
+      this._rejectPending(tempId2, new Error(reason));
+    }
+  }
   /**
    * Try to re-send a pending frame after a transient server reject
    * (currently only NC-RATE-001 — the tenant's per-second token bucket
@@ -2208,9 +2236,22 @@ var NoveraChat = class {
   async connect() {
     await this.ws.connect();
   }
+  /**
+   * 소켓을 닫는다. **Room 파사드와 그 메시지 상태는 유지한다** — `connect()`
+   * 로 다시 붙으면 같은 파사드가 그대로 이어서 프레임을 받는다.
+   *
+   * 예전엔 여기서 `rooms.clear()` 를 했는데, 그러면 UI 가 들고 있던 컬렉션이
+   * 다음 접근 때 빈 컬렉션으로 교체돼 이미 로드한 히스토리가 사라졌다
+   * (React StrictMode 의 connect → disconnect → connect 에서 채팅방이 빈
+   * 화면으로 뜨는 증상). 소켓은 재사용되는 `ReconnectingWs` 인스턴스라
+   * 파사드가 참조를 유지해도 문제가 없다.
+   *
+   * 다만 ack 를 기다리던 전송은 응답 받을 길이 없으므로 여기서 실패로
+   * 정리한다(낙관적 버블이 영원히 `sending` 으로 남지 않도록).
+   */
   disconnect() {
     this.ws.close();
-    this.rooms.clear();
+    for (const room of this.rooms.values()) room._failPendingSends("disconnected");
   }
   room(roomId) {
     let r = this.rooms.get(roomId);

package/dist/index.d.cts

@@ -666,6 +666,17 @@ declare class ReconnectingWs {
     private explicitClose;
     private outboundQueue;
     private static readonly OUTBOUND_QUEUE_CAP;
+    /**
+     * 연결 시도의 세대 번호 — `connect()`/`close()` 마다 올린다.
+     *
+     * `openOnce()` 는 `urlBuilder()`(토큰 발급 왕복)를 await 하는 동안 아직
+     * 소켓이 없어서, 그 틈에 들어온 `close()` 는 닫을 대상을 찾지 못한다.
+     * 이어서 새 `connect()` 가 `explicitClose` 를 되돌리면, 뒤늦게 깨어난
+     * 앞선 시도가 **아무도 닫지 않는 소켓**을 하나 더 만든다(React StrictMode 의
+     * mount → cleanup → mount 에서 재현). 불리언 하나로는 "이미 취소됐다"를
+     * 알릴 수 없으므로 세대 번호로 판별한다.
+     */
+    private gen;
     constructor(opts: ReconnectingWsOptions);
     get currentState(): WsState;
     connect(): Promise<void>;
@@ -1337,6 +1348,12 @@ declare class Room {
      *  fail the matching outbound promise immediately instead of waiting
      *  for the 15s ack timeout. */
     _rejectPending(tempId: string, err: Error): void;
+    /**
+     * ack 를 기다리던 전송을 전부 실패 처리한다 — `chat.disconnect()` 처럼
+     * 응답이 올 길이 사라졌을 때. 메시지 컬렉션은 건드리지 않는다(낙관적
+     * 버블은 `failed` 로 바뀌어 재전송 UI 를 띄울 수 있다).
+     */
+    _failPendingSends(reason: string): void;
     /**
      * Try to re-send a pending frame after a transient server reject
      * (currently only NC-RATE-001 — the tenant's per-second token bucket
@@ -1415,6 +1432,19 @@ declare class NoveraChat {
     private lastPresenceKey;
     constructor(opts: ClientOptions);
     connect(): Promise<void>;
+    /**
+     * 소켓을 닫는다. **Room 파사드와 그 메시지 상태는 유지한다** — `connect()`
+     * 로 다시 붙으면 같은 파사드가 그대로 이어서 프레임을 받는다.
+     *
+     * 예전엔 여기서 `rooms.clear()` 를 했는데, 그러면 UI 가 들고 있던 컬렉션이
+     * 다음 접근 때 빈 컬렉션으로 교체돼 이미 로드한 히스토리가 사라졌다
+     * (React StrictMode 의 connect → disconnect → connect 에서 채팅방이 빈
+     * 화면으로 뜨는 증상). 소켓은 재사용되는 `ReconnectingWs` 인스턴스라
+     * 파사드가 참조를 유지해도 문제가 없다.
+     *
+     * 다만 ack 를 기다리던 전송은 응답 받을 길이 없으므로 여기서 실패로
+     * 정리한다(낙관적 버블이 영원히 `sending` 으로 남지 않도록).
+     */
     disconnect(): void;
     room(roomId: string): Room;
     /** Subscribe to client-level events. Currently `roomEvent` — membership /

package/dist/index.d.ts

@@ -666,6 +666,17 @@ declare class ReconnectingWs {
     private explicitClose;
     private outboundQueue;
     private static readonly OUTBOUND_QUEUE_CAP;
+    /**
+     * 연결 시도의 세대 번호 — `connect()`/`close()` 마다 올린다.
+     *
+     * `openOnce()` 는 `urlBuilder()`(토큰 발급 왕복)를 await 하는 동안 아직
+     * 소켓이 없어서, 그 틈에 들어온 `close()` 는 닫을 대상을 찾지 못한다.
+     * 이어서 새 `connect()` 가 `explicitClose` 를 되돌리면, 뒤늦게 깨어난
+     * 앞선 시도가 **아무도 닫지 않는 소켓**을 하나 더 만든다(React StrictMode 의
+     * mount → cleanup → mount 에서 재현). 불리언 하나로는 "이미 취소됐다"를
+     * 알릴 수 없으므로 세대 번호로 판별한다.
+     */
+    private gen;
     constructor(opts: ReconnectingWsOptions);
     get currentState(): WsState;
     connect(): Promise<void>;
@@ -1337,6 +1348,12 @@ declare class Room {
      *  fail the matching outbound promise immediately instead of waiting
      *  for the 15s ack timeout. */
     _rejectPending(tempId: string, err: Error): void;
+    /**
+     * ack 를 기다리던 전송을 전부 실패 처리한다 — `chat.disconnect()` 처럼
+     * 응답이 올 길이 사라졌을 때. 메시지 컬렉션은 건드리지 않는다(낙관적
+     * 버블은 `failed` 로 바뀌어 재전송 UI 를 띄울 수 있다).
+     */
+    _failPendingSends(reason: string): void;
     /**
      * Try to re-send a pending frame after a transient server reject
      * (currently only NC-RATE-001 — the tenant's per-second token bucket
@@ -1415,6 +1432,19 @@ declare class NoveraChat {
     private lastPresenceKey;
     constructor(opts: ClientOptions);
     connect(): Promise<void>;
+    /**
+     * 소켓을 닫는다. **Room 파사드와 그 메시지 상태는 유지한다** — `connect()`
+     * 로 다시 붙으면 같은 파사드가 그대로 이어서 프레임을 받는다.
+     *
+     * 예전엔 여기서 `rooms.clear()` 를 했는데, 그러면 UI 가 들고 있던 컬렉션이
+     * 다음 접근 때 빈 컬렉션으로 교체돼 이미 로드한 히스토리가 사라졌다
+     * (React StrictMode 의 connect → disconnect → connect 에서 채팅방이 빈
+     * 화면으로 뜨는 증상). 소켓은 재사용되는 `ReconnectingWs` 인스턴스라
+     * 파사드가 참조를 유지해도 문제가 없다.
+     *
+     * 다만 ack 를 기다리던 전송은 응답 받을 길이 없으므로 여기서 실패로
+     * 정리한다(낙관적 버블이 영원히 `sending` 으로 남지 않도록).
+     */
     disconnect(): void;
     room(roomId: string): Room;
     /** Subscribe to client-level events. Currently `roomEvent` — membership /

package/dist/index.js

@@ -368,14 +368,26 @@ var ReconnectingWs = class _ReconnectingWs {
   // heartbeats and a stale typing event is worse than no event.
   outboundQueue = [];
   static OUTBOUND_QUEUE_CAP = 200;
+  /**
+   * 연결 시도의 세대 번호 — `connect()`/`close()` 마다 올린다.
+   *
+   * `openOnce()` 는 `urlBuilder()`(토큰 발급 왕복)를 await 하는 동안 아직
+   * 소켓이 없어서, 그 틈에 들어온 `close()` 는 닫을 대상을 찾지 못한다.
+   * 이어서 새 `connect()` 가 `explicitClose` 를 되돌리면, 뒤늦게 깨어난
+   * 앞선 시도가 **아무도 닫지 않는 소켓**을 하나 더 만든다(React StrictMode 의
+   * mount → cleanup → mount 에서 재현). 불리언 하나로는 "이미 취소됐다"를
+   * 알릴 수 없으므로 세대 번호로 판별한다.
+   */
+  gen = 0;
   get currentState() {
     return this.state;
   }
   async connect() {
     this.explicitClose = false;
-    await this.openOnce();
+    await this.openOnce(++this.gen);
   }
   close() {
+    this.gen++;
     this.explicitClose = true;
     this.setState("closed");
     if (this.pingTimer) clearInterval(this.pingTimer);
@@ -408,7 +420,8 @@ var ReconnectingWs = class _ReconnectingWs {
     );
     return true;
   }
-  async openOnce() {
+  async openOnce(gen) {
+    if (gen !== this.gen) return;
     this.setState(this.attempt === 0 ? "connecting" : "reconnecting");
     const WSImpl = this.opts.WebSocketImpl ?? globalThis.WebSocket;
     if (!WSImpl) throw new Error("No WebSocket implementation available");
@@ -417,7 +430,11 @@ var ReconnectingWs = class _ReconnectingWs {
       url = await this.opts.urlBuilder();
     } catch (err) {
       this.opts.logger?.("error", "url_builder_failed", err);
-      this.scheduleReconnect();
+      if (gen === this.gen) this.scheduleReconnect();
+      return;
+    }
+    if (gen !== this.gen) {
+      this.opts.logger?.("info", "ws_open_aborted_stale", { gen, current: this.gen });
       return;
     }
     const ws = new WSImpl(url);
@@ -482,8 +499,9 @@ var ReconnectingWs = class _ReconnectingWs {
     const delay = exp + jitter;
     this.opts.logger?.("info", "ws_reconnect_scheduled", { attempt: this.attempt, delay });
     this.setState("reconnecting");
+    const gen = this.gen;
     setTimeout(() => {
-      void this.openOnce();
+      void this.openOnce(gen);
     }, delay);
   }
   startPings() {
@@ -2013,6 +2031,16 @@ var Room = class _Room {
     this.pendingAcks.delete(tempId2);
     this.mySentTempIds.delete(tempId2);
   }
+  /**
+   * ack 를 기다리던 전송을 전부 실패 처리한다 — `chat.disconnect()` 처럼
+   * 응답이 올 길이 사라졌을 때. 메시지 컬렉션은 건드리지 않는다(낙관적
+   * 버블은 `failed` 로 바뀌어 재전송 UI 를 띄울 수 있다).
+   */
+  _failPendingSends(reason) {
+    for (const tempId2 of [...this.pendingAcks.keys()]) {
+      this._rejectPending(tempId2, new Error(reason));
+    }
+  }
   /**
    * Try to re-send a pending frame after a transient server reject
    * (currently only NC-RATE-001 — the tenant's per-second token bucket
@@ -2173,9 +2201,22 @@ var NoveraChat = class {
   async connect() {
     await this.ws.connect();
   }
+  /**
+   * 소켓을 닫는다. **Room 파사드와 그 메시지 상태는 유지한다** — `connect()`
+   * 로 다시 붙으면 같은 파사드가 그대로 이어서 프레임을 받는다.
+   *
+   * 예전엔 여기서 `rooms.clear()` 를 했는데, 그러면 UI 가 들고 있던 컬렉션이
+   * 다음 접근 때 빈 컬렉션으로 교체돼 이미 로드한 히스토리가 사라졌다
+   * (React StrictMode 의 connect → disconnect → connect 에서 채팅방이 빈
+   * 화면으로 뜨는 증상). 소켓은 재사용되는 `ReconnectingWs` 인스턴스라
+   * 파사드가 참조를 유지해도 문제가 없다.
+   *
+   * 다만 ack 를 기다리던 전송은 응답 받을 길이 없으므로 여기서 실패로
+   * 정리한다(낙관적 버블이 영원히 `sending` 으로 남지 않도록).
+   */
   disconnect() {
     this.ws.close();
-    this.rooms.clear();
+    for (const room of this.rooms.values()) room._failPendingSends("disconnected");
   }
   room(roomId) {
     let r = this.rooms.get(roomId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noverachat/sdk-web",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "NoveraChat browser/Node SDK — WebSocket + REST client with optimistic UI, reconnection and gap-fill",
   "license": "MIT",
   "type": "module",

package/src/client.ts

@@ -149,9 +149,22 @@ export class NoveraChat {
     await this.ws.connect();
   }
 
+  /**
+   * 소켓을 닫는다. **Room 파사드와 그 메시지 상태는 유지한다** — `connect()`
+   * 로 다시 붙으면 같은 파사드가 그대로 이어서 프레임을 받는다.
+   *
+   * 예전엔 여기서 `rooms.clear()` 를 했는데, 그러면 UI 가 들고 있던 컬렉션이
+   * 다음 접근 때 빈 컬렉션으로 교체돼 이미 로드한 히스토리가 사라졌다
+   * (React StrictMode 의 connect → disconnect → connect 에서 채팅방이 빈
+   * 화면으로 뜨는 증상). 소켓은 재사용되는 `ReconnectingWs` 인스턴스라
+   * 파사드가 참조를 유지해도 문제가 없다.
+   *
+   * 다만 ack 를 기다리던 전송은 응답 받을 길이 없으므로 여기서 실패로
+   * 정리한다(낙관적 버블이 영원히 `sending` 으로 남지 않도록).
+   */
   disconnect(): void {
     this.ws.close();
-    this.rooms.clear();
+    for (const room of this.rooms.values()) room._failPendingSends("disconnected");
   }
 
   room(roomId: string): Room {

package/src/features/room.ts

@@ -1246,6 +1246,17 @@ export class Room {
     this.mySentTempIds.delete(tempId);
   }
 
+  /**
+   * ack 를 기다리던 전송을 전부 실패 처리한다 — `chat.disconnect()` 처럼
+   * 응답이 올 길이 사라졌을 때. 메시지 컬렉션은 건드리지 않는다(낙관적
+   * 버블은 `failed` 로 바뀌어 재전송 UI 를 띄울 수 있다).
+   */
+  _failPendingSends(reason: string): void {
+    for (const tempId of [...this.pendingAcks.keys()]) {
+      this._rejectPending(tempId, new Error(reason));
+    }
+  }
+
   /**
    * Try to re-send a pending frame after a transient server reject
    * (currently only NC-RATE-001 — the tenant's per-second token bucket

package/src/transport/ws.ts

@@ -41,6 +41,17 @@ export class ReconnectingWs {
   // heartbeats and a stale typing event is worse than no event.
   private outboundQueue: WsOutbound[] = [];
   private static readonly OUTBOUND_QUEUE_CAP = 200;
+  /**
+   * 연결 시도의 세대 번호 — `connect()`/`close()` 마다 올린다.
+   *
+   * `openOnce()` 는 `urlBuilder()`(토큰 발급 왕복)를 await 하는 동안 아직
+   * 소켓이 없어서, 그 틈에 들어온 `close()` 는 닫을 대상을 찾지 못한다.
+   * 이어서 새 `connect()` 가 `explicitClose` 를 되돌리면, 뒤늦게 깨어난
+   * 앞선 시도가 **아무도 닫지 않는 소켓**을 하나 더 만든다(React StrictMode 의
+   * mount → cleanup → mount 에서 재현). 불리언 하나로는 "이미 취소됐다"를
+   * 알릴 수 없으므로 세대 번호로 판별한다.
+   */
+  private gen = 0;
 
   constructor(private opts: ReconnectingWsOptions) {}
 
@@ -50,10 +61,11 @@ export class ReconnectingWs {
 
   async connect(): Promise<void> {
     this.explicitClose = false;
-    await this.openOnce();
+    await this.openOnce(++this.gen);
   }
 
   close(): void {
+    this.gen++; // 진행 중인 연결 시도를 모두 무효화한다
     this.explicitClose = true;
     this.setState("closed");
     if (this.pingTimer) clearInterval(this.pingTimer);
@@ -91,7 +103,8 @@ export class ReconnectingWs {
     return true;
   }
 
-  private async openOnce(): Promise<void> {
+  private async openOnce(gen: number): Promise<void> {
+    if (gen !== this.gen) return;
     this.setState(this.attempt === 0 ? "connecting" : "reconnecting");
     const WSImpl = this.opts.WebSocketImpl ?? (globalThis.WebSocket as typeof WebSocket);
     if (!WSImpl) throw new Error("No WebSocket implementation available");
@@ -101,7 +114,14 @@ export class ReconnectingWs {
       url = await this.opts.urlBuilder();
     } catch (err) {
       this.opts.logger?.("error", "url_builder_failed", err);
-      this.scheduleReconnect();
+      if (gen === this.gen) this.scheduleReconnect();
+      return;
+    }
+
+    // await 사이에 close()/connect() 가 지나갔으면 이 시도는 이미 취소된
+    // 것이다 — 소켓을 만들지 않고 물러난다(누수 소켓 방지).
+    if (gen !== this.gen) {
+      this.opts.logger?.("info", "ws_open_aborted_stale", { gen, current: this.gen });
       return;
     }
 
@@ -175,8 +195,9 @@ export class ReconnectingWs {
     const delay = exp + jitter;
     this.opts.logger?.("info", "ws_reconnect_scheduled", { attempt: this.attempt, delay });
     this.setState("reconnecting");
+    const gen = this.gen; // 예약 시점의 세대 — 그사이 close/connect 가 오면 취소
     setTimeout(() => {
-      void this.openOnce();
+      void this.openOnce(gen);
     }, delay);
   }