polfan-server-js-client 0.2.108 → 0.2.109

package/build/types/AbstractChatClient.d.ts

@@ -14,16 +14,6 @@ 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). The server will never reply to those commands, so
-     * leaving them pending would hang every caller awaiting them forever -
-     * including cached lookups in the state tracker, which would then keep a
-     * view stuck on a loader even after a successful reconnect.
-     */
-    protected failAwaitingResponses(error: any): void;
 }
 export type CommandResult<ResultT> = {
     data?: ResultT;

package/build/types/IndexedObjectCollection.d.ts

@@ -51,14 +51,6 @@ 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,13 +45,7 @@ export declare class WebSocketChatClient extends AbstractChatClient<Pick<WebSock
     protected sendQueue: Envelope[];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
-    protected authenticatedResolvers: [() => void, (error: Error) => void] | null;
-    /**
-     * Pending promise returned by connect(). Kept until the client is either
-     * authenticated or gives up, so that an automatic reconnect settles the
-     * original caller instead of stranding it on a superseded promise.
-     */
-    protected connectPromise: Promise<void> | null;
+    protected authenticatedResolvers: [() => void, (error: Error) => void];
     protected pingMonitorInterval?: NodeJS.Timeout;
     protected inFlightPingTimeout: NodeJS.Timeout;
     protected lastReceivedMessageAt?: number;
@@ -63,16 +57,6 @@ 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

@@ -16,11 +16,6 @@ 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.
@@ -65,19 +60,6 @@ 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,18 +13,6 @@ 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(force?: boolean): Promise<void>;
+    resetToLatest(): 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(force?: boolean): Promise<void>;
+    resetToLatest(): 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.108",
+  "version": "0.2.109",
   "description": "JavaScript client library for handling communication with Polfan chat server.",
   "author": "Jarosław Żak",
   "license": "MIT",

package/src/AbstractChatClient.ts

@@ -165,28 +165,6 @@ 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). The server will never reply to those commands, so
-     * leaving them pending would hang every caller awaiting them forever -
-     * including cached lookups in the state tracker, which would then keep a
-     * view stuck on a loader even after a successful reconnect.
-     */
-    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,37 +226,6 @@ 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,13 +48,7 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
     protected sendQueue: Envelope[] = [];
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
-    protected authenticatedResolvers: [() => void, (error: Error) => void] | null = null;
-    /**
-     * Pending promise returned by connect(). Kept until the client is either
-     * authenticated or gives up, so that an automatic reconnect settles the
-     * original caller instead of stranding it on a superseded promise.
-     */
-    protected connectPromise: Promise<void> | null = null;
+    protected authenticatedResolvers: [() => void, (error: Error) => void];
     protected pingMonitorInterval?: NodeJS.Timeout;
     protected inFlightPingTimeout: NodeJS.Timeout;
     protected lastReceivedMessageAt?: number;
@@ -73,14 +67,9 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
 
     public async connect(): Promise<void> {
         if (this.isOpenWsState() || this.isConnectingWsState()) {
-            return this.connectPromise ?? undefined;
+            return;
         }
 
-        // 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);
 
@@ -92,12 +81,11 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
             this.options.connectingTimeoutMs ?? 10000
         );
         this.authenticated = false;
-
-        return this.connectPromise;
+        return new Promise((...args) => this.authenticatedResolvers = args);
     }
 
     public disconnect(): void {
-        this.failPendingCommands(new Error('Client disconnected before the command was answered'));
+        this.sendQueue = [];
         this.ws?.close(1000); // Normal closure
         this.ws = null;
     }
@@ -145,11 +133,11 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
             this.authenticated = isAuthenticated;
             if (isAuthenticated) {
                 this.startConnectionMonitor();
-                this.settleConnect();
+                this.authenticatedResolvers[0]();
                 this.emit(this.Event.connect);
                 this.sendFromQueue();
             } else {
-                this.settleConnect(envelope.data);
+                this.authenticatedResolvers[1](envelope.data);
             }
         }
     }
@@ -158,54 +146,12 @@ 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;
@@ -252,9 +198,7 @@ export class WebSocketChatClient extends AbstractChatClient<Pick<WebSocketEventM
                 this.ws.close(3000); // Service Restart (reconnect)
             }, this.options.ping.pongBackTimeoutMs);
 
-            // 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(() => {
+            this.send('Ping', {}).then(() => {
                 clearTimeout(this.inFlightPingTimeout);
                 this.inFlightPingTimeout = undefined;
             });

package/src/state-tracker/AsyncUtils.ts

@@ -14,17 +14,6 @@ export class PromiseRegistry {
 
     public register<T = any>(promise: Promise<T>, key: string): void {
         this.promises.set([key, promise]);
-
-        // Never cache a failed lookup: drop it so the next access retries
-        // instead of replaying the same rejection forever (a request issued
-        // while the client was offline would otherwise poison the key). The
-        // handler also keeps the cached promise from surfacing as an unhandled
-        // rejection - callers still receive the rejection from their own await.
-        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,10 +44,8 @@ export class EmoticonsManager {
             this.list.set([spaceId, new ObservableIndexedObjectCollection<Emoticon>('id')]);
         }
 
-        // 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);
+        const collection = this.list.get(spaceId);
+        collection.set(...event.emoticons);
     }
 
     private handleNewEmoticon(ev: NewEmoticon): void {
@@ -65,9 +63,7 @@ export class EmoticonsManager {
     }
 
     private handleSession(): void {
-        // 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.list.deleteAll();
         this.emoticonsPromises.forgetAll();
     }
 }

package/src/state-tracker/FollowedTopicsManager.ts

@@ -29,12 +29,6 @@ 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();
 
@@ -69,8 +63,8 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return;
         }
 
-        const needsFetch = roomIds.some(roomId => ! this.followedTopics.has(roomId) || this.staleRooms.has(roomId));
-        if (! needsFetch) {
+        const isAlreadyCached = roomIds.every(roomId => this.followedTopics.has(roomId));
+        if (isAlreadyCached) {
             return;
         }
 
@@ -81,7 +75,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                 const result = await this.tracker.client.send('GetFollowedTopics', {location: {spaceId}});
                 if (result.error) throw result.error;
 
-                this.reconcileRoomsFollowedTopics(roomIds, result.data.followedTopics);
+                this.setFollowedTopicsArray(roomIds, result.data.followedTopics);
             }, spaceRegistryKey);
         }
 
@@ -97,7 +91,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return undefined;
         }
 
-        if (! this.followedTopics.has(roomId) || this.staleRooms.has(roomId)) {
+        if (! this.followedTopics.has(roomId)) {
             if (this.followedTopicsPromises.notExist(roomId)) {
                 this.followedTopicsPromises.registerByFunction(async () => {
                     const result = await this.tracker.client.send('GetFollowedTopics', {location: {roomId}});
@@ -106,8 +100,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                         throw result.error;
                     }
 
-                    this.applyRoomFollowedTopics(roomId, result.data.followedTopics);
-                    this.invalidateUnreadSummaries(roomId);
+                    this.setFollowedTopicsArray([roomId], result.data.followedTopics);
                 }, roomId);
             }
 
@@ -212,13 +205,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     }
 
     private handleSession(ev: Session): void {
-        // 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.followedTopics.deleteAll();
         this.followedTopicsPromises.forgetAll();
         this.invalidateUnreadSummaries();
         this.deferredSession.resolve();
@@ -370,40 +357,6 @@ 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[]} = {};
 
@@ -431,7 +384,6 @@ 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,27 +71,8 @@ export class MessagesManager {
     }
 
     private handleSession(ev: Session): void {
-        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.roomHistories.deleteAll();
+        ev.state.rooms.forEach(room => this.createHistoryForNewRoom(room));
         this.deferredSession.resolve();
     }
 }

package/src/state-tracker/PermissionsManager.ts

@@ -308,11 +308,7 @@ export class PermissionsManager extends EventTarget<PermissionsManagerEventMap>
     }
 
     private handleSession(ev: Session): void {
-        // 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.overwrites.deleteAll();
         this.overwritesPromises.forgetAll();
-        this.emit('change');
     }
 }

package/src/state-tracker/RelationshipsManager.ts

@@ -43,9 +43,10 @@ export class RelationshipsManager {
     }
 
     private handleRelationships(ev: Relationships): void {
-        // 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);
+        this.relationships.deleteAll();
+        ev.relationships.forEach(relationship => {
+            this.relationships.set(relationship);
+        });
     }
 
     private handleNewRelationship(ev: NewRelationship): void {
@@ -61,8 +62,7 @@ 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, WindowState} from "./TopicHistoryWindow";
+import {TopicHistoryWindow} from "./TopicHistoryWindow";
 
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
@@ -39,46 +39,6 @@ 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,33 +303,16 @@ 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 {
-        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.list.deleteAll();
+        this.topics.deleteAll();
         this.topicsPromises.forgetAll();
+        this.members.deleteAll();
+        this.membersPromises.forgetAll();
 
-        // Upsert surviving/new rooms from the authoritative snapshot.
         this.addJoinedRooms(...ev.state.rooms);
 
         this.deferredSession.resolve();