polfan-server-js-client 0.2.108 → 0.2.110

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();

package/src/state-tracker/SpacesManager.ts

@@ -227,20 +227,14 @@ export class SpacesManager {
                 ev.id,
                 new ObservableIndexedObjectCollection(member => member?.user.id, 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 handleSpaceRooms(ev: SpaceRooms): void {
-        if (! this.rooms.has(ev.id)) {
+        if (!this.rooms.has(ev.id)) {
             this.rooms.set([ev.id, new ObservableIndexedObjectCollection('id', ev.summaries)]);
-        } else {
-            this.rooms.get(ev.id).reconcile(...ev.summaries);
+            ev.summaries.forEach(summary => this.roomIdToSpaceId.set([summary.id, ev.id]));
         }
-        ev.summaries.forEach(summary => this.roomIdToSpaceId.set([summary.id, ev.id]));
     }
 
     private async handleRoomSummaryUpdated(ev: RoomSummaryUpdated): Promise<void> {
@@ -292,36 +286,15 @@ export class SpacesManager {
     }
 
     private handleSession(ev: Session): void {
-        const stateSpaceIds = new Set(ev.state.spaces.map(space => space.id));
-
-        // Remove only spaces that were left/deleted on the server during the
-        // downtime, reusing the cascade cleanup (roles, rooms, members, index).
-        const removedSpaceIds = this.list.items
-            .filter(space => ! stateSpaceIds.has(space.id))
-            .map(space => space.id);
-        for (const spaceId of removedSpaceIds) {
-            this.handleSpaceDeleted({ id: spaceId } as SpaceDeleted);
-        }
-
-        // Invalidate lazy caches (rooms/members) but keep their objects so the
-        // next access refetches and reconciles them in place.
+        this.list.deleteAll();
+        this.roles.deleteAll();
+        this.rooms.deleteAll();
         this.roomsPromises.forgetAll();
+        this.members.deleteAll();
         this.membersPromises.forgetAll();
+        this.roomIdToSpaceId.deleteAll();
 
-        // Reconcile roles in place (kept, possibly bound object) and upsert the
-        // spaces from the authoritative snapshot.
-        for (const space of ev.state.spaces) {
-            if (this.roles.has(space.id)) {
-                this.roles.get(space.id).reconcile(...space.roles);
-            } else {
-                this.roles.set([
-                    space.id,
-                    new ObservableIndexedObjectCollection<Role>('id', space.roles),
-                ]);
-            }
-        }
-
-        this.list.set(...ev.state.spaces);
+        this.addJoinedSpaces(...ev.state.spaces);
 
         this.deferredSession.resolve();
     }

package/src/state-tracker/TopicHistoryWindow.ts

@@ -111,8 +111,8 @@ export abstract class TraversableRemoteCollection<
 
     public abstract createMirror(): TraversableRemoteCollection<ItemT, EventMapT>;
 
-    public async resetToLatest(force: boolean = false): Promise<void> {
-        if (this.internalState.ongoing || (! force && this.internalState.current === WindowState.LATEST)) {
+    public async resetToLatest(): Promise<void> {
+        if (this.internalState.ongoing || this.internalState.current === WindowState.LATEST) {
             return;
         }
 
@@ -340,11 +340,11 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
         }
     }
 
-    public async resetToLatest(force: boolean = false): Promise<void> {
+    public async resetToLatest(): Promise<void> {
         if (this.internalState.traverseLock) {
             return;
         }
-        return super.resetToLatest(force);
+        return super.resetToLatest();
     }
 
     public async fetchNext(): Promise<void> {

package/src/state-tracker/UsersManager.ts

@@ -33,9 +33,7 @@ export class UsersManager {
     }
 
     private handleSession(session: Session): void {
-        // Keep the "seen users" cache across reconnects so bound user lists do
-        // not blank out; just ensure our own user is present/updated. Stale
-        // entries are refreshed as member/message collections refetch.
+        this.users.deleteAll();
         this.handleUsers([session.user]);
     }
 

package/tests/collections.test.ts

@@ -759,96 +759,4 @@ describe('ObservableIndexedObjectCollection', () => {
         expect(mirror.get('2')).toBeDefined();
         expect(mirror.length).toBe(2);
     });
-
-    test('reconcile - upserts new/changed items and deletes absent ones', () => {
-        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
-            createItem('1', 'first'),
-            createItem('2', 'second'),
-            createItem('3', 'third'),
-        ]);
-
-        // Keep 1 (changed), keep 3 (unchanged), drop 2, add 4.
-        collection.reconcile(
-            createItem('1', 'first-renamed'),
-            createItem('3', 'third'),
-            createItem('4', 'fourth'),
-        );
-
-        expect(collection.length).toBe(3);
-        expect(collection.get('1')?.name).toBe('first-renamed');
-        expect(collection.get('2')).toBeUndefined();
-        expect(collection.get('3')?.name).toBe('third');
-        expect(collection.get('4')?.name).toBe('fourth');
-    });
-
-    test('reconcile - emits a single change event with set and deleted ids', () => {
-        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
-            createItem('1', 'first'),
-            createItem('2', 'second'),
-        ]);
-        const handler = jest.fn();
-        collection.on('change', handler);
-
-        collection.reconcile(createItem('1', 'first'), createItem('3', 'third'));
-
-        expect(handler).toHaveBeenCalledTimes(1);
-        expect(handler).toHaveBeenCalledWith({ setItems: ['1', '3'], deletedItems: ['2'] });
-    });
-
-    test('reconcile - never blanks: existing item stays present the whole time', () => {
-        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
-            createItem('1', 'first'),
-            createItem('2', 'second'),
-        ]);
-
-        // A change listener that reads the collection while it is being
-        // reconciled must never observe an empty/partial intermediate state.
-        const seenLengths: number[] = [];
-        collection.on('change', () => seenLengths.push(collection.length));
-
-        collection.reconcile(createItem('1', 'first'), createItem('3', 'third'));
-
-        // Only the final state (2 items) is ever visible - no 0-length frame.
-        expect(seenLengths).toEqual([2]);
-    });
-
-    test('reconcile - does not emit when nothing changes structurally on empty input', () => {
-        const collection = new ObservableIndexedObjectCollection<TestItem>('id');
-        const handler = jest.fn();
-        collection.on('change', handler);
-
-        collection.reconcile();
-
-        expect(handler).not.toHaveBeenCalled();
-        expect(collection.length).toBe(0);
-    });
-
-    test('reconcile - reconciling to empty clears the collection', () => {
-        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
-            createItem('1', 'first'),
-        ]);
-        const handler = jest.fn();
-        collection.on('change', handler);
-
-        collection.reconcile();
-
-        expect(collection.length).toBe(0);
-        expect(handler).toHaveBeenCalledWith({ setItems: [], deletedItems: ['1'] });
-    });
-
-    test('reconcile - preserves collection identity (mirror sees updates)', () => {
-        const collection = new ObservableIndexedObjectCollection<TestItem>('id', [
-            createItem('1', 'first'),
-            createItem('2', 'second'),
-        ]);
-        const mirror = collection.createMirror();
-
-        collection.reconcile(createItem('2', 'second'), createItem('3', 'third'));
-
-        // The mirror shares the same underlying items, so it reflects the
-        // reconcile without being re-created.
-        expect(mirror.get('1')).toBeUndefined();
-        expect(mirror.get('3')?.name).toBe('third');
-        expect(mirror.length).toBe(2);
-    });
 });

package/tests/pending-commands.test.ts

@@ -1,171 +0,0 @@
-import {PromiseRegistry} from "../src/state-tracker/AsyncUtils";
-import {AbstractChatClient} from "../src/AbstractChatClient";
-import {TraversableRemoteCollection, WindowState} from "../src/state-tracker/TopicHistoryWindow";
-import {Envelope} from "../src/types/src";
-
-/**
- * A command issued while the client is offline (or one that is still in flight
- * when the socket drops) must always settle. Leaving it pending strands every
- * caller awaiting it - including the state tracker's cached lookups and the
- * history window's `ongoing` guard, which would keep a view stuck on a loader
- * (or permanently empty) even after a successful reconnect.
- */
-
-class TestableChatClient extends AbstractChatClient {
-    public async send(type: any, data: any): Promise<any> {
-        const envelope = this.createEnvelope(type, data);
-        return this.createPromiseFromCommandEnvelope(envelope as any);
-    }
-
-    public respond(ref: string, type: string, data: any): void {
-        this.handleIncomingEnvelope({ ref, type, data } as Envelope);
-    }
-
-    public dropConnection(error: Error): void {
-        this.failAwaitingResponses(error);
-    }
-
-    public get pendingCount(): number {
-        return this.awaitingResponse.size;
-    }
-}
-
-describe('pending commands settle on connection loss', () => {
-    test('in-flight commands reject instead of hanging forever', async () => {
-        const client = new TestableChatClient();
-
-        const first = client.send('GetMessages', {});
-        const second = client.send('GetRoomMembers', {});
-
-        expect(client.pendingCount).toBe(2);
-
-        client.dropConnection(new Error('Connection closed'));
-
-        await expect(first).rejects.toThrow('Connection closed');
-        await expect(second).rejects.toThrow('Connection closed');
-        expect(client.pendingCount).toBe(0);
-    });
-
-    test('commands answered before the drop are unaffected', async () => {
-        const client = new TestableChatClient();
-
-        const answered = client.send('GetMessages', {});
-        client.respond('1', 'Messages', { messages: [] });
-
-        const inFlight = client.send('GetRoomMembers', {});
-        client.dropConnection(new Error('Connection closed'));
-
-        await expect(answered).resolves.toEqual({ data: { messages: [] }, error: null });
-        await expect(inFlight).rejects.toThrow('Connection closed');
-    });
-});
-
-describe('PromiseRegistry does not cache failures', () => {
-    test('a rejected lookup is forgotten so the next access retries', async () => {
-        const registry = new PromiseRegistry();
-        let attempts = 0;
-
-        const run = async () => {
-            registry.registerByFunction(async () => {
-                attempts++;
-                if (attempts === 1) {
-                    throw new Error('offline');
-                }
-                return 'ok';
-            }, 'key');
-
-            return registry.get('key');
-        };
-
-        // First attempt fails while "offline".
-        await expect(run()).rejects.toThrow('offline');
-
-        // The failed entry must not be cached, otherwise every later access
-        // would replay the same rejection forever.
-        expect(registry.notExist('key')).toBe(true);
-
-        await expect(run()).resolves.toBe('ok');
-        expect(attempts).toBe(2);
-    });
-
-    test('a successful lookup stays cached', async () => {
-        const registry = new PromiseRegistry();
-        let attempts = 0;
-
-        registry.registerByFunction(async () => {
-            attempts++;
-            return 'ok';
-        }, 'key');
-
-        await registry.get('key');
-
-        expect(registry.has('key')).toBe(true);
-        expect(attempts).toBe(1);
-    });
-
-    test('a newer entry for the same key is not dropped by an older failure', async () => {
-        const registry = new PromiseRegistry();
-
-        const failing = Promise.reject(new Error('offline'));
-        registry.register(failing, 'key');
-        await expect(registry.get('key')).rejects.toThrow('offline');
-
-        const succeeding = Promise.resolve('ok');
-        registry.register(succeeding, 'key');
-
-        // Let the older rejection's cleanup handler run.
-        await new Promise(resolve => setTimeout(resolve, 0));
-
-        expect(registry.has('key')).toBe(true);
-        await expect(registry.get('key')).resolves.toBe('ok');
-    });
-});
-
-describe('history window survives a failed fetch', () => {
-    interface SimpleMessage { id: number }
-
-    class FlakyWindow extends TraversableRemoteCollection<SimpleMessage> {
-        public shouldFail = false;
-
-        public constructor() {
-            super('id');
-        }
-
-        public createMirror(): TraversableRemoteCollection<SimpleMessage> {
-            throw new Error('Method not implemented.');
-        }
-
-        protected async fetchLatestItems(): Promise<SimpleMessage[]> {
-            if (this.shouldFail) {
-                throw new Error('Connection closed before the command was answered');
-            }
-            return [{ id: 1 }, { id: 2 }];
-        }
-
-        protected async fetchItemsBefore(): Promise<SimpleMessage[] | null> { return []; }
-        protected async fetchItemsAfter(): Promise<SimpleMessage[] | null> { return []; }
-        protected async fetchItemsAround(): Promise<SimpleMessage[] | null> { return []; }
-        protected async isLatestItemLoaded(): Promise<boolean> { return true; }
-    }
-
-    test('a rejected fetch leaves the window reusable, not permanently blocked', async () => {
-        const window = new FlakyWindow();
-
-        // Simulates opening a room while the client is offline.
-        window.shouldFail = true;
-        await expect(window.resetToLatest()).rejects.toThrow('Connection closed');
-
-        // The failure must not leave the internal `ongoing` guard set, which
-        // would make every later fetch a silent no-op and strand the view on an
-        // empty window after the reconnect.
-        expect(window.state).toBe(WindowState.LIVE);
-        expect(window.length).toBe(0);
-
-        // Retry after reconnecting must actually fetch.
-        window.shouldFail = false;
-        await window.resetToLatest();
-
-        expect(window.state).toBe(WindowState.LATEST);
-        expect(window.items.map(item => item.id)).toEqual([1, 2]);
-    });
-})

package/tests/state-reconnect.test.ts

@@ -1,257 +0,0 @@
-import {EventTarget} from "../src/EventTarget";
-import {RoomsManager} from "../src/state-tracker/RoomsManager";
-import {SpacesManager} from "../src/state-tracker/SpacesManager";
-import {WindowState} from "../src/state-tracker/TopicHistoryWindow";
-
-/**
- * These tests exercise the reconnect (second `Session`) reconciliation path of
- * the state tracker: collections must keep their identity, surviving rooms and
- * spaces must not be wiped and rebuilt, ephemeral message history must be
- * preserved, and only the entities actually removed on the server may be
- * dropped. See ChatStateTracker managers `handleSession`.
- */
-
-type Responder = (data: any) => any;
-
-class FakeClient extends EventTarget {
-    public readonly sent: { type: string; data: any }[] = [];
-    private readonly responders: Record<string, Responder> = {};
-
-    public respondTo(type: string, responder: Responder): void {
-        this.responders[type] = responder;
-    }
-
-    public async send(type: string, data: any): Promise<{ data: any; error: any }> {
-        this.sent.push({ type, data });
-        const responder = this.responders[type];
-        return { data: responder ? responder(data) : undefined, error: null };
-    }
-
-    public countSent(type: string): number {
-        return this.sent.filter(entry => entry.type === type).length;
-    }
-}
-
-const flush = async (): Promise<void> => {
-    // Drain microtasks scheduled by the fire-and-forget resync chain.
-    await new Promise(resolve => setTimeout(resolve, 0));
-    await new Promise(resolve => setTimeout(resolve, 0));
-};
-
-const createRoom = (id: string, overrides: any = {}): any => ({
-    id,
-    spaceId: null,
-    name: id,
-    description: '',
-    type: 'Text',
-    defaultTopic: { id: `topic-${id}`, messageCount: 0, lastMessage: null },
-    recipients: null,
-    flags: 0,
-    stream: null,
-    history: { mode: 'Full' },
-    ...overrides,
-});
-
-const createSpace = (id: string, roles: any[] = []): any => ({
-    id,
-    name: id,
-    roles,
-    defaultRooms: [],
-    systemRoom: null,
-});
-
-const emitSession = (client: FakeClient, rooms: any[], spaces: any[] = []): void => {
-    client.emit('Session', {
-        serverVersion: '1.0.0',
-        protoVersion: '1.0.0',
-        user: { id: 'me' },
-        state: { rooms, spaces },
-    } as any);
-};
-
-const createTracker = () => {
-    const client = new FakeClient();
-    const tracker: any = { client, getMe: async () => ({ id: 'me' }) };
-    tracker.rooms = new RoomsManager(tracker);
-    tracker.spaces = new SpacesManager(tracker);
-    return { client, tracker };
-};
-
-describe('reconnect - RoomsManager', () => {
-    test('preserves the rooms list identity and reconciles membership', async () => {
-        const { client, tracker } = createTracker();
-
-        emitSession(client, [createRoom('A'), createRoom('B')]);
-        const list = await tracker.rooms.get();
-
-        expect(list.items.map((r: any) => r.id).sort()).toEqual(['A', 'B']);
-
-        // Reconnect: B is gone, C joined, A survived (renamed).
-        emitSession(client, [createRoom('A', { name: 'A-renamed' }), createRoom('C')]);
-        const listAfter = await tracker.rooms.get();
-
-        expect(listAfter).toBe(list); // same object -> bindings intact
-        expect(listAfter.items.map((r: any) => r.id).sort()).toEqual(['A', 'C']);
-        expect(listAfter.get('A').name).toBe('A-renamed');
-        expect(listAfter.get('B')).toBeUndefined();
-    });
-
-    test('keeps a member collection object across reconnect and refetches it', async () => {
-        const { client, tracker } = createTracker();
-        client.respondTo('GetRoomMembers', (data: any) => ({
-            id: data.id,
-            members: [
-                { user: { id: 'me' }, spaceMember: null, roles: null, customColor: null, customNick: null, extras: '' },
-                { user: { id: 'u1' }, spaceMember: null, roles: null, customColor: null, customNick: null, extras: '' },
-            ],
-        }));
-
-        emitSession(client, [createRoom('A')]);
-        const membersBefore = await tracker.rooms.getMembers('A');
-        expect(membersBefore.items.map((m: any) => m.user.id).sort()).toEqual(['me', 'u1']);
-        expect(client.countSent('GetRoomMembers')).toBe(1);
-
-        // After reconnect u1 has left; the refetch must reconcile in place.
-        client.respondTo('GetRoomMembers', (data: any) => ({
-            id: data.id,
-            members: [
-                { user: { id: 'me' }, spaceMember: null, roles: null, customColor: null, customNick: null, extras: '' },
-            ],
-        }));
-
-        emitSession(client, [createRoom('A')]);
-        const membersAfter = await tracker.rooms.getMembers('A');
-
-        expect(membersAfter).toBe(membersBefore); // same object -> no blank
-        expect(client.countSent('GetRoomMembers')).toBe(2); // guard was dropped -> refetched
-        expect(membersAfter.items.map((m: any) => m.user.id)).toEqual(['me']);
-    });
-});
-
-describe('reconnect - MessagesManager', () => {
-    const emitNewMessage = (client: FakeClient, roomId: string, topicId: string, id: string): void => {
-        client.emit('NewMessage', {
-            message: {
-                id,
-                type: 'Text',
-                content: '',
-                location: { roomId, topicId },
-                author: { user: { id: 'other' } },
-            },
-        } as any);
-    };
-
-    test('preserves ephemeral live history across reconnect (no refetch, no loss)', async () => {
-        const { client, tracker } = createTracker();
-
-        emitSession(client, [createRoom('E', { history: { mode: 'Ephemeral' } })]);
-
-        const history = await tracker.rooms.messages.getRoomHistory('E');
-        const window = await history.getMessagesWindow('topic-E');
-        expect(window.state).toBe(WindowState.LIVE);
-
-        emitNewMessage(client, 'E', 'topic-E', 'm1');
-        emitNewMessage(client, 'E', 'topic-E', 'm2');
-        expect(window.items.map((m: any) => m.id)).toEqual(['m1', 'm2']);
-
-        client.sent.length = 0;
-
-        // Reconnect - the whole point: ephemeral context must survive.
-        emitSession(client, [createRoom('E', { history: { mode: 'Ephemeral' } })]);
-        await flush();
-
-        const historyAfter = await tracker.rooms.messages.getRoomHistory('E');
-        const windowAfter = await historyAfter.getMessagesWindow('topic-E');
-
-        expect(historyAfter).toBe(history); // history object preserved
-        expect(windowAfter).toBe(window);   // window object preserved
-        expect(windowAfter.items.map((m: any) => m.id)).toEqual(['m1', 'm2']);
-        expect(client.countSent('GetMessages')).toBe(0); // never refetched
-    });
-
-    test('refreshes a LATEST window but leaves an untouched LIVE window alone', async () => {
-        const { client, tracker } = createTracker();
-        client.respondTo('GetMessages', () => ({ messages: [{ id: 'x1' }, { id: 'x2' }] }));
-
-        // R was opened (pulled to LATEST); L was only ever created (LIVE).
-        emitSession(client, [createRoom('R'), createRoom('L')]);
-
-        const rHistory = await tracker.rooms.messages.getRoomHistory('R');
-        const rWindow = await rHistory.getMessagesWindow('topic-R');
-        await rWindow.resetToLatest();
-        expect(rWindow.state).toBe(WindowState.LATEST);
-
-        const lHistory = await tracker.rooms.messages.getRoomHistory('L');
-        const lWindow = await lHistory.getMessagesWindow('topic-L');
-        expect(lWindow.state).toBe(WindowState.LIVE);
-
-        client.sent.length = 0;
-
-        emitSession(client, [createRoom('R'), createRoom('L')]);
-        await flush();
-
-        // LATEST window was refreshed with exactly one request; identity kept.
-        expect((await tracker.rooms.messages.getRoomHistory('R'))).toBe(rHistory);
-        expect(client.sent.filter(e => e.type === 'GetMessages'
-            && e.data.location.roomId === 'R').length).toBe(1);
-        // LIVE window (never pulled by the app) was left untouched.
-        expect(client.sent.filter(e => e.type === 'GetMessages'
-            && e.data.location.roomId === 'L').length).toBe(0);
-    });
-});
-
-describe('reconnect - SpacesManager', () => {
-    test('reconciles roles in place and drops only removed spaces', async () => {
-        const { client, tracker } = createTracker();
-
-        const s1Roles = [
-            { id: 'r1', name: 'everyone', priority: 0, color: '#fff' },
-            { id: 'r2', name: 'mod', priority: 1, color: '#fff' },
-        ];
-        emitSession(client, [], [createSpace('S1', s1Roles), createSpace('S2')]);
-
-        const spaces = await tracker.spaces.get();
-        const rolesS1 = await tracker.spaces.getRoles('S1');
-        expect(spaces.items.map((s: any) => s.id).sort()).toEqual(['S1', 'S2']);
-        expect(rolesS1.items.map((r: any) => r.id).sort()).toEqual(['r1', 'r2']);
-
-        // Reconnect: S2 removed, S3 joined; S1 roles changed (r2 removed, r3 added).
-        const s1RolesNew = [
-            { id: 'r1', name: 'everyone', priority: 0, color: '#fff' },
-            { id: 'r3', name: 'vip', priority: 2, color: '#fff' },
-        ];
-        emitSession(client, [], [createSpace('S1', s1RolesNew), createSpace('S3')]);
-
-        const spacesAfter = await tracker.spaces.get();
-        const rolesS1After = await tracker.spaces.getRoles('S1');
-
-        expect(spacesAfter).toBe(spaces);
-        expect(spacesAfter.items.map((s: any) => s.id).sort()).toEqual(['S1', 'S3']);
-        expect(rolesS1After).toBe(rolesS1); // roles collection identity preserved
-        expect(rolesS1After.items.map((r: any) => r.id).sort()).toEqual(['r1', 'r3']);
-    });
-
-    test('keeps a space member collection across reconnect and refetches it', async () => {
-        const { client, tracker } = createTracker();
-        client.respondTo('GetSpaceMembers', (data: any) => ({
-            id: data.id,
-            members: [{ user: { id: 'me' } }, { user: { id: 'u1' } }],
-        }));
-
-        emitSession(client, [], [createSpace('S1')]);
-        const membersBefore = await tracker.spaces.getMembers('S1');
-        expect(client.countSent('GetSpaceMembers')).toBe(1);
-
-        client.respondTo('GetSpaceMembers', (data: any) => ({
-            id: data.id,
-            members: [{ user: { id: 'me' } }],
-        }));
-
-        emitSession(client, [], [createSpace('S1')]);
-        const membersAfter = await tracker.spaces.getMembers('S1');
-
-        expect(membersAfter).toBe(membersBefore);
-        expect(client.countSent('GetSpaceMembers')).toBe(2);
-        expect(membersAfter.items.map((m: any) => m.user.id)).toEqual(['me']);
-    });
-});