polfan-server-js-client 0.2.110 → 0.2.111

package/build/types/AbstractChatClient.d.ts

@@ -14,6 +14,12 @@ export declare abstract class AbstractChatClient<AdditionalEvents extends ExtraE
     protected createPromiseFromCommandEnvelope<CommandT extends keyof CommandsMap>(envelope: Envelope<CommandRequest<CommandT>>): Promise<CommandResult<CommandResponse<CommandT>>>;
     protected handleIncomingEnvelope(envelope: Envelope): void;
     protected handleEnvelopeSendError(envelope: Envelope, error: any): void;
+    /**
+     * Reject every command that is still waiting for a response.
+     * Call this whenever the transport can no longer deliver an answer (the
+     * connection dropped).
+     */
+    protected failAwaitingResponses(error: any): void;
 }
 export type CommandResult<ResultT> = {
     data?: ResultT;

package/build/types/IndexedObjectCollection.d.ts

@@ -51,6 +51,14 @@ export declare class ObservableIndexedObjectCollection<ItemT, EventMapT extends
     set(...items: ItemT[]): void;
     delete(...ids: string[]): void;
     deleteAll(): void;
+    /**
+     * Bring the collection to exactly match the provided items: upsert every
+     * provided item and remove any existing item whose id is not present in the
+     * provided set. Emits at most a single `change` event describing both the
+     * set and the deleted ids, so bound consumers can update in place without
+     * ever observing an intermediate empty state (unlike deleteAll + set).
+     */
+    reconcile(...items: ItemT[]): void;
     createMirror(): ObservableIndexedObjectCollection<ItemT, EventMapT>;
     on<EventName extends keyof EventMapT & string>(eventName: EventName, handler: EventHandler<EventMapT[EventName]>): this;
     once<EventName extends keyof EventMapT & string>(eventName: EventName, handler: EventHandler<EventMapT[EventName]>): this;

package/build/types/WebSocketChatClient.d.ts

@@ -45,7 +45,8 @@ export declare class WebSocketChatClient extends AbstractChatClient<Pick<WebSock
     protected sendQueue: Envelope[];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
-    protected authenticatedResolvers: [() => void, (error: Error) => void];
+    protected authenticatedResolvers: [() => void, (error: Error) => void] | null;
+    protected connectPromise: Promise<void> | null;
     protected pingMonitorInterval?: NodeJS.Timeout;
     protected inFlightPingTimeout: NodeJS.Timeout;
     protected lastReceivedMessageAt?: number;
@@ -57,6 +58,16 @@ export declare class WebSocketChatClient extends AbstractChatClient<Pick<WebSock
     private sendEnvelope;
     private onMessage;
     private onClose;
+    /**
+     * Resolve (or reject, when an error is given) a pending connect() promise.
+     * No-op when there is nothing pending.
+     */
+    private settleConnect;
+    /**
+     * Reject every command that has not been answered yet - both the ones still
+     * waiting in the send queue and the ones already sent to the server.
+     */
+    private failPendingCommands;
     private sendFromQueue;
     private triggerConnectionTimeout;
     private isConnectingWsState;

package/build/types/state-tracker/FollowedTopicsManager.d.ts

@@ -17,6 +17,11 @@ export declare class FollowedTopicsManager extends EventTarget<EventMap> {
     private readonly followedTopicsPromises;
     private readonly deferredSession;
     private readonly summariesCache;
+    /**
+     * Rooms whose cached followed-topics are stale after a reconnect and must
+     * be refetched (and reconciled in place) the next time they are accessed.
+     */
+    private readonly staleRooms;
     constructor(tracker: ChatStateTracker);
     /**
      * Cache followed topics for all joined rooms in a space and fetch them in bulk if necessary.
@@ -61,6 +66,19 @@ export declare class FollowedTopicsManager extends EventTarget<EventMap> {
     private invalidateUnreadSummaries;
     private invalidateUnreadSummariesForRooms;
     private updateLocallyFollowedTopicOnNewMessage;
+    /**
+     * Reconcile the followed-topics collection for a single room to exactly
+     * match the provided list (upsert present, drop absent) without emitting an
+     * intermediate empty state, and clear its stale marker. Does not touch the
+     * unread summaries cache - callers decide how to invalidate it.
+     */
+    private applyRoomFollowedTopics;
+    /**
+     * Reconcile a batch of rooms from a single bulk GetFollowedTopics response.
+     * Rooms with no followed topics in the response are reconciled to empty, so
+     * topics unfollowed/removed during the downtime are correctly dropped.
+     */
+    private reconcileRoomsFollowedTopics;
     private setFollowedTopicsArray;
     private clearRoomFollowedTopicsStructures;
 }

package/build/types/state-tracker/RoomMessagesHistory.d.ts

@@ -13,6 +13,18 @@ export declare class RoomMessagesHistory {
      * @param peek If true, do not create a cache for this topic and do not allow it to collect new messages.
      */
     getMessagesWindow(topicId: string, peek?: boolean): Promise<TopicHistoryWindow | undefined>;
+    /**
+     * Re-synchronise this room's history after a reconnect without discarding
+     * the existing window objects (which would blank the UI and, for ephemeral
+     * rooms, permanently drop live-only history).
+     *
+     * The window bindings are preserved; only windows that the application had
+     * actually pulled to the latest page (state === LATEST) are refreshed, with
+     * a single resetToLatest instead of a chain of catch-up requests. Windows
+     * that were never pulled (LIVE) or belong to an ephemeral room are left
+     * untouched so their in-memory context survives the reconnect.
+     */
+    resync(room: Room): Promise<void>;
     private handleRoomUpdated;
     private handleNewTopic;
     private handleTopicDeleted;

package/build/types/state-tracker/TopicHistoryWindow.d.ts

@@ -64,7 +64,7 @@ export declare abstract class TraversableRemoteCollection<ItemT, EventMapT exten
     get hasLatest(): boolean;
     get hasOldest(): boolean;
     abstract createMirror(): TraversableRemoteCollection<ItemT, EventMapT>;
-    resetToLatest(): Promise<void>;
+    resetToLatest(force?: boolean): Promise<void>;
     fetchPrevious(): Promise<void>;
     fetchNext(): Promise<void>;
     jumpTo(id: string): Promise<void>;
@@ -99,7 +99,7 @@ export declare class TopicHistoryWindow extends TraversableRemoteCollection<Mess
     createMirror(): TopicHistoryWindow;
     get isTraverseLocked(): boolean;
     setTraverseLock(lock: boolean): Promise<void>;
-    resetToLatest(): Promise<void>;
+    resetToLatest(force?: boolean): Promise<void>;
     fetchNext(): Promise<void>;
     fetchPrevious(): Promise<void>;
     jumpTo(id: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polfan-server-js-client",
-  "version": "0.2.110",
+  "version": "0.2.111",
   "description": "JavaScript client library for handling communication with Polfan chat server.",
   "author": "Jarosław Żak",
   "license": "MIT",

package/src/AbstractChatClient.ts

@@ -165,6 +165,24 @@ export abstract class AbstractChatClient<AdditionalEvents extends ExtraEventMap
         this.awaitingResponse.get(envelope.ref)[1](error);
         this.awaitingResponse.delete(envelope.ref);
     }
+
+    /**
+     * Reject every command that is still waiting for a response.
+     * Call this whenever the transport can no longer deliver an answer (the
+     * connection dropped).
+     */
+    protected failAwaitingResponses(error: any): void {
+        if (! this.awaitingResponse.size) {
+            return;
+        }
+
+        const pending = Array.from(this.awaitingResponse.values());
+        this.awaitingResponse.clear();
+
+        for (const [, reject] of pending) {
+            reject(error);
+        }
+    }
 }
 
 export type CommandResult<ResultT> = {data?: ResultT, error?: ErrorType};

package/src/IndexedObjectCollection.ts

@@ -226,6 +226,37 @@ export class ObservableIndexedObjectCollection<
         }
     }
 
+    /**
+     * Bring the collection to exactly match the provided items: upsert every
+     * provided item and remove any existing item whose id is not present in the
+     * provided set. Emits at most a single `change` event describing both the
+     * set and the deleted ids, so bound consumers can update in place without
+     * ever observing an intermediate empty state (unlike deleteAll + set).
+     */
+    public reconcile(...items: ItemT[]) {
+        const incomingIds = new Set(items.map(item => this.getId(item)));
+        const deletedItems: string[] = [];
+
+        for (const existing of this.items) {
+            const id = this.getId(existing);
+            if (! incomingIds.has(id)) {
+                deletedItems.push(id);
+            }
+        }
+
+        if (! items.length && ! deletedItems.length) {
+            return;
+        }
+
+        this._items.delete(...deletedItems);
+        super.set(...items);
+
+        this.eventTarget.emit('change', {
+            setItems: items.map(item => this.getId(item)),
+            deletedItems,
+        });
+    }
+
     public createMirror(): ObservableIndexedObjectCollection<ItemT, EventMapT> {
         const copy = new ObservableIndexedObjectCollection<ItemT, EventMapT>(this.id);
         copy.eventTarget = this.eventTarget;

package/src/WebSocketChatClient.ts

@@ -48,7 +48,8 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
     protected sendQueue: Envelope[] = [];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
-    protected authenticatedResolvers: [() => void, (error: Error) => void];
+    protected authenticatedResolvers: [() => void, (error: Error) => void] | null = null;
+    protected connectPromise: Promise<void> | null = null;
     protected pingMonitorInterval?: NodeJS.Timeout;
     protected inFlightPingTimeout: NodeJS.Timeout;
     protected lastReceivedMessageAt?: number;
@@ -67,9 +68,14 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
 
     public async connect(): Promise<void> {
         if (this.isOpenWsState() || this.isConnectingWsState()) {
-            return;
+            return this.connectPromise ?? undefined;
         }
 
+        // Reuse the promise of an attempt that has not settled yet (an
+        // automatic reconnect), so the caller that started connecting is
+        // resolved by whichever attempt eventually authenticates.
+        this.connectPromise ??= new Promise<void>((...args) => this.authenticatedResolvers = args);
+
         const params = new URLSearchParams(this.options.queryParams ?? {});
         params.set('token', this.options.token);
 
@@ -81,11 +87,12 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
             this.options.connectingTimeoutMs ?? 10000
         );
         this.authenticated = false;
-        return new Promise((...args) => this.authenticatedResolvers = args);
+
+        return this.connectPromise;
     }
 
     public disconnect(): void {
-        this.sendQueue = [];
+        this.failPendingCommands(new Error('Client disconnected before the command was answered'));
         this.ws?.close(1000); // Normal closure
         this.ws = null;
     }
@@ -133,11 +140,11 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
             this.authenticated = isAuthenticated;
             if (isAuthenticated) {
                 this.startConnectionMonitor();
-                this.authenticatedResolvers[0]();
+                this.settleConnect();
                 this.emit(this.Event.connect);
                 this.sendFromQueue();
             } else {
-                this.authenticatedResolvers[1](envelope.data);
+                this.settleConnect(envelope.data);
             }
         }
     }
@@ -146,12 +153,54 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
         this.stopConnectionMonitor();
         clearTimeout(this.connectingTimeoutId);
         const reconnect = event.code !== 1000; // Connection was closed because of error
+
+        // The server can no longer answer anything that was queued or in
+        // flight, so settle those promises instead of leaving them pending.
+        this.failPendingCommands(new Error('Connection closed before the command was answered'));
+
         if (reconnect) {
+            // Keep a pending connect() promise unsettled - the retry below is
+            // expected to authenticate and will resolve it.
             void this.connect();
+        } else {
+            this.settleConnect(new Error('Connection closed before authentication'));
         }
+
         this.emit(this.Event.disconnect, reconnect);
     }
 
+    /**
+     * Resolve (or reject, when an error is given) a pending connect() promise.
+     * No-op when there is nothing pending.
+     */
+    private settleConnect(error?: any): void {
+        const resolvers = this.authenticatedResolvers;
+
+        this.authenticatedResolvers = null;
+        this.connectPromise = null;
+
+        if (! resolvers) {
+            return;
+        }
+
+        error ? resolvers[1](error) : resolvers[0]();
+    }
+
+    /**
+     * Reject every command that has not been answered yet - both the ones still
+     * waiting in the send queue and the ones already sent to the server.
+     */
+    private failPendingCommands(error: Error): void {
+        const queued = this.sendQueue;
+        this.sendQueue = [];
+
+        for (const envelope of queued) {
+            this.handleEnvelopeSendError(envelope, error);
+        }
+
+        this.failAwaitingResponses(error);
+    }
+
     private sendFromQueue(): void {
         // Send awaiting data to server
         let lastDelay = 0;
@@ -198,7 +247,9 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
                 this.ws.close(3000); // Service Restart (reconnect)
             }, this.options.ping.pongBackTimeoutMs);
 
-            this.send('Ping', {}).then(() => {
+            // A rejection here means the connection dropped while the ping was
+            // in flight; onClose already handles that, so just stop waiting.
+            this.send('Ping', {}).catch(() => undefined).then(() => {
                 clearTimeout(this.inFlightPingTimeout);
                 this.inFlightPingTimeout = undefined;
             });

package/src/state-tracker/AsyncUtils.ts

@@ -14,6 +14,12 @@ export class PromiseRegistry {
 
     public register<T = any>(promise: Promise<T>, key: string): void {
         this.promises.set([key, promise]);
+
+        promise.catch(() => {
+            if (this.promises.get(key) === promise) {
+                this.promises.delete(key);
+            }
+        });
     }
 
     public registerByFunction(fn: () => Promise<any>, key: string): void {

package/src/state-tracker/EmoticonsManager.ts

@@ -44,8 +44,10 @@ export class EmoticonsManager {
             this.list.set([spaceId, new ObservableIndexedObjectCollection<Emoticon>('id')]);
         }
 
-        const collection = this.list.get(spaceId);
-        collection.set(...event.emoticons);
+        // handleEmoticons always carries the full list for a location, so
+        // reconcile in place: a reconnect refetch drops removed emoticons and
+        // adds new ones without blanking a bound (visible) collection.
+        this.list.get(spaceId).reconcile(...event.emoticons);
     }
 
     private handleNewEmoticon(ev: NewEmoticon): void {
@@ -63,7 +65,9 @@ export class EmoticonsManager {
     }
 
     private handleSession(): void {
-        this.list.deleteAll();
+        // Keep cached emoticon collections (they may be bound to visible
+        // pickers); just drop the fetch guards so the next access refetches and
+        // reconciles them in place.
         this.emoticonsPromises.forgetAll();
     }
 }

package/src/state-tracker/FollowedTopicsManager.ts

@@ -30,6 +30,12 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     private readonly deferredSession = new DeferredTask();
     private readonly summariesCache = new Map<string, UnreadSummary>();
 
+    /**
+     * Rooms whose cached followed-topics are stale after a reconnect and must
+     * be refetched (and reconciled in place) the next time they are accessed.
+     */
+    private readonly staleRooms = new Set<string>();
+
     public constructor(private tracker: ChatStateTracker) {
         super();
 
@@ -64,8 +70,8 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return;
         }
 
-        const isAlreadyCached = roomIds.every(roomId => this.followedTopics.has(roomId));
-        if (isAlreadyCached) {
+        const needsFetch = roomIds.some(roomId => ! this.followedTopics.has(roomId) || this.staleRooms.has(roomId));
+        if (! needsFetch) {
             return;
         }
 
@@ -76,7 +82,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                 const result = await this.tracker.client.send('GetFollowedTopics', {location: {spaceId}});
                 if (result.error) throw result.error;
 
-                this.setFollowedTopicsArray(roomIds, result.data.followedTopics);
+                this.reconcileRoomsFollowedTopics(roomIds, result.data.followedTopics);
             }, spaceRegistryKey);
         }
 
@@ -92,7 +98,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return undefined;
         }
 
-        if (! this.followedTopics.has(roomId)) {
+        if (! this.followedTopics.has(roomId) || this.staleRooms.has(roomId)) {
             if (this.followedTopicsPromises.notExist(roomId)) {
                 this.followedTopicsPromises.registerByFunction(async () => {
                     const result = await this.tracker.client.send('GetFollowedTopics', {location: {roomId}});
@@ -101,7 +107,8 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                         throw result.error;
                     }
 
-                    this.setFollowedTopicsArray([roomId], result.data.followedTopics);
+                    this.applyRoomFollowedTopics(roomId, result.data.followedTopics);
+                    this.invalidateUnreadSummaries(roomId);
                 }, roomId);
             }
 
@@ -212,7 +219,13 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     }
 
     private handleSession(ev: Session): void {
-        this.followedTopics.deleteAll();
+        // Keep cached followed-topic collections (they drive unread indicators
+        // that would otherwise blank on reconnect), but mark them stale and drop
+        // the fetch guards so the next access/caching refetches and reconciles
+        // them in place.
+        for (const roomId of this.followedTopics.items.keys()) {
+            this.staleRooms.add(roomId);
+        }
         this.followedTopicsPromises.forgetAll();
         this.invalidateUnreadSummaries();
         this.deferredSession.resolve();
@@ -364,6 +377,40 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
         this.invalidateUnreadSummaries(ev.message.location.roomId, ev.message.location.topicId);
     }
 
+    /**
+     * Reconcile the followed-topics collection for a single room to exactly
+     * match the provided list (upsert present, drop absent) without emitting an
+     * intermediate empty state, and clear its stale marker. Does not touch the
+     * unread summaries cache - callers decide how to invalidate it.
+     */
+    private applyRoomFollowedTopics(roomId: string, followedTopics: FollowedTopic[]): void {
+        if (! this.followedTopics.has(roomId)) {
+            this.followedTopics.set([roomId, new ObservableIndexedObjectCollection<FollowedTopic>(
+                followedTopic => followedTopic.location.topicId
+            )]);
+        }
+
+        this.followedTopics.get(roomId).reconcile(...followedTopics);
+        this.staleRooms.delete(roomId);
+    }
+
+    /**
+     * Reconcile a batch of rooms from a single bulk GetFollowedTopics response.
+     * Rooms with no followed topics in the response are reconciled to empty, so
+     * topics unfollowed/removed during the downtime are correctly dropped.
+     */
+    private reconcileRoomsFollowedTopics(roomIds: string[], followedTopics: FollowedTopic[]): void {
+        const roomToTopics: {[roomId: string]: FollowedTopic[]} = {};
+
+        followedTopics.forEach(followedTopic => {
+            (roomToTopics[followedTopic.location.roomId] ??= []).push(followedTopic);
+        });
+
+        roomIds.forEach(roomId => this.applyRoomFollowedTopics(roomId, roomToTopics[roomId] ?? []));
+
+        this.invalidateUnreadSummariesForRooms(roomIds);
+    }
+
     private setFollowedTopicsArray(roomIds: string[], followedTopics: FollowedTopic[]): void {
         const roomToTopics: {[roomId: string]: FollowedTopic[]} = {};
 
@@ -391,6 +438,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     private clearRoomFollowedTopicsStructures(roomId: string): void {
         this.followedTopics.delete(roomId);
         this.followedTopicsPromises.forget(roomId);
+        this.staleRooms.delete(roomId);
         this.invalidateUnreadSummaries(roomId);
     }
 }

package/src/state-tracker/MessagesManager.ts

@@ -71,8 +71,27 @@ export class MessagesManager {
     }
 
     private handleSession(ev: Session): void {
-        this.roomHistories.deleteAll();
-        ev.state.rooms.forEach(room => this.createHistoryForNewRoom(room));
+        const stateRoomIds = new Set(ev.state.rooms.map(room => room.id));
+
+        // Drop histories only for rooms that no longer exist server-side.
+        for (const roomId of Array.from(this.roomHistories.items.keys())) {
+            if (! stateRoomIds.has(roomId)) {
+                this.roomHistories.delete(roomId);
+            }
+        }
+
+        // Keep existing histories (preserving loaded messages and, crucially,
+        // live-only ephemeral history), create histories for newly joined
+        // rooms, and resync survivors against the fresh room snapshot.
+        for (const room of ev.state.rooms) {
+            const history = this.roomHistories.get(room.id);
+            if (history) {
+                void history.resync(room);
+            } else {
+                this.createHistoryForNewRoom(room);
+            }
+        }
+
         this.deferredSession.resolve();
     }
 }

package/src/state-tracker/PermissionsManager.ts

@@ -308,7 +308,11 @@ export class PermissionsManager extends EventTarget<PermissionsManagerEventMap>
     }
 
     private handleSession(ev: Session): void {
-        this.overwrites.deleteAll();
+        // Drop the fetch guards so permission checks recompute against fresh
+        // overwrites (getOverwrites refetches and upserts on the next access),
+        // and notify consumers to recompute so bound permission UI is never
+        // left showing stale results after a reconnect.
         this.overwritesPromises.forgetAll();
+        this.emit('change');
     }
 }

package/src/state-tracker/RelationshipsManager.ts

@@ -43,10 +43,9 @@ export class RelationshipsManager {
     }
 
     private handleRelationships(ev: Relationships): void {
-        this.relationships.deleteAll();
-        ev.relationships.forEach(relationship => {
-            this.relationships.set(relationship);
-        });
+        // Full list from the server: reconcile in place so a reconnect refetch
+        // updates a bound (visible) list without an intermediate empty state.
+        this.relationships.reconcile(...ev.relationships);
     }
 
     private handleNewRelationship(ev: NewRelationship): void {
@@ -62,7 +61,8 @@ export class RelationshipsManager {
     }
 
     private handleSession(): void {
+        // Keep the (possibly bound) collection; just drop the fetch guard so the
+        // next get() refetches and reconciles it in place.
         this.promises.forgetAll();
-        this.relationships.deleteAll();
     }
 }

package/src/state-tracker/RoomMessagesHistory.ts

@@ -1,7 +1,7 @@
 import {ChatStateTracker} from "./ChatStateTracker";
 import {NewTopic, Room, RoomUpdated, Topic, TopicDeleted} from "../types/src";
 import {IndexedCollection,} from "../IndexedObjectCollection";
-import {TopicHistoryWindow} from "./TopicHistoryWindow";
+import {TopicHistoryWindow, WindowState} from "./TopicHistoryWindow";
 
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
@@ -39,6 +39,46 @@ export class RoomMessagesHistory {
         return this.historyWindows.get(topicId);
     }
 
+    /**
+     * Re-synchronise this room's history after a reconnect without discarding
+     * the existing window objects (which would blank the UI and, for ephemeral
+     * rooms, permanently drop live-only history).
+     *
+     * The window bindings are preserved; only windows that the application had
+     * actually pulled to the latest page (state === LATEST) are refreshed, with
+     * a single resetToLatest instead of a chain of catch-up requests. Windows
+     * that were never pulled (LIVE) or belong to an ephemeral room are left
+     * untouched so their in-memory context survives the reconnect.
+     */
+    public async resync(room: Room): Promise<void> {
+        this.room = room;
+        this.updateTraverseLock(room);
+
+        if (this.room.defaultTopic) {
+            this.createHistoryWindowForTopic(this.room.defaultTopic);
+        }
+
+        for (const [, window] of Array.from(this.historyWindows.items)) {
+            try {
+                await window.setTraverseLock(this.traverseLock);
+
+                // Ephemeral history lives only in memory (the server does not
+                // persist it), so never refetch/replace it on reconnect.
+                if (this.traverseLock) {
+                    continue;
+                }
+
+                if (window.state === WindowState.LATEST) {
+                    await window.resetToLatest(true);
+                }
+            } catch (_e) {
+                // Best effort: the connection can drop again mid-resync. The
+                // window keeps its current content and stays usable, so the
+                // application can refresh it on demand.
+            }
+        }
+    }
+
     private async handleRoomUpdated(ev: RoomUpdated): Promise<void> {
         if (this.room.id === ev.room.id) {
             this.room = ev.room;

package/src/state-tracker/RoomsManager.ts

@@ -303,16 +303,33 @@ export class RoomsManager {
                     ev.members,
                 )
             ]);
+        } else {
+            // Reconcile into the existing (bound) collection so a reconnect
+            // refetch updates it in place instead of leaving stale members.
+            this.members.get(ev.id).reconcile(...ev.members);
         }
     }
 
     private handleSession(ev: Session): void {
-        this.list.deleteAll();
-        this.topics.deleteAll();
-        this.topicsPromises.forgetAll();
-        this.members.deleteAll();
+        const stateRoomIds = new Set(ev.state.rooms.map(room => room.id));
+
+        // Remove only rooms that were left/deleted on the server during the
+        // downtime, reusing the cascade cleanup (members, topics, followed
+        // topics). Surviving rooms keep their identity and bindings.
+        const removedRoomIds = this.list.items
+            .filter(room => ! stateRoomIds.has(room.id))
+            .map(room => room.id);
+        if (removedRoomIds.length) {
+            this.deleteRoom(...removedRoomIds);
+        }
+
+        // Invalidate lazy caches so the next access refetches fresh data, but
+        // keep the collection objects: handleRoomMembers reconciles into them,
+        // so bound views refresh in place without blanking.
         this.membersPromises.forgetAll();
+        this.topicsPromises.forgetAll();
 
+        // Upsert surviving/new rooms from the authoritative snapshot.
         this.addJoinedRooms(...ev.state.rooms);
 
         this.deferredSession.resolve();