Draft: Refresh room timeline when we see a MSC2716 marker event

src/@types/event.ts

@@ -87,6 +87,8 @@ export enum EventType {
     RoomKeyRequest = "m.room_key_request",
     ForwardedRoomKey = "m.forwarded_room_key",
     Dummy = "m.dummy",
+
+    Marker = "org.matrix.msc2716.marker", // MSC2716
 }
 
 export enum RelationType {

src/client.ts

@@ -799,6 +799,7 @@ type RoomStateEvents = RoomStateEvent.Events
     | RoomStateEvent.Members
     | RoomStateEvent.NewMember
     | RoomStateEvent.Update
+    | RoomStateEvent.Marker
     ;
 
 type CryptoEvents = CryptoEvent.KeySignatureUploadFailure

src/models/room-state.ts

@@ -42,6 +42,7 @@ export enum RoomStateEvent {
     NewMember = "RoomState.newMember",
     Update = "RoomState.update", // signals batches of updates without specificity
     BeaconLiveness = "RoomState.BeaconLiveness",
+    Marker = "RoomState.org.matrix.msc2716.marker",
 }
 
 export type RoomStateEventHandlerMap = {
@@ -51,6 +52,7 @@ export type RoomStateEventHandlerMap = {
     [RoomStateEvent.Update]: (state: RoomState) => void;
     [RoomStateEvent.BeaconLiveness]: (state: RoomState, hasLiveBeacons: boolean) => void;
     [BeaconEvent.New]: (event: MatrixEvent, beacon: Beacon) => void;
+    [RoomStateEvent.Marker]: (event: MatrixEvent, state: RoomState) => void;
 };
 
 type EmittedEvents = RoomStateEvent | BeaconEvent;
@@ -398,6 +400,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
                 // assume all our sentinels are now out-of-date
                 this.sentinels = {};
+            } else if (event.getType() === EventType.Marker) {
+                this.emit(RoomStateEvent.Marker, event, this);
             }
         });
 

src/models/room.ts

@@ -204,6 +204,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
     public readonly threadsTimelineSets: EventTimelineSet[] = [];
     // any filtered timeline sets we're maintaining for this room
     private readonly filteredTimelineSets: Record<string, EventTimelineSet> = {}; // filter_id: timelineSet
+    private lastMarkerEventIdProcessed: string = null;
     private readonly pendingEventList?: MatrixEvent[];
     // read by megolm via getter; boolean value - null indicates "use global value"
     private blacklistUnverifiedDevices: boolean = null;
@@ -439,6 +440,19 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
         return Promise.allSettled(decryptionPromises) as unknown as Promise<void>;
     }
 
+    /**
+     * Gets the creator of the room
+     * @returns {string} The creator of the room, or null if it could not be determined
+     */
+    public getRoomCreator(): string | null {
+        const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
+        if (!createEvent) {
+            return null;
+        }
+        const roomCreator = createEvent.getContent()['sender'];
+        return roomCreator;
+    }
+
     /**
      * Gets the version of the room
      * @returns {string} The version of the room, or null if it could not be determined
@@ -1004,6 +1018,25 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
         return this.getUnfilteredTimelineSet().addTimeline();
     }
 
+    /**
+     * Get the last marker event ID proccessed
+     *
+     * @return {String} the last marker event ID proccessed or null if none have
+     * been processed
+     */
+    public getLastMarkerEventIdProcessed(): string | null {
+        return this.lastMarkerEventIdProcessed;
+    }
+
+    /**
+     * Set the last marker event ID proccessed
+     *
+     * @param {String} eventId The marker event ID to set
+     */
+    public setLastMarkerEventIdProcessed(eventId: string): void {
+        this.lastMarkerEventIdProcessed = eventId;
+    }
+
     /**
      * Get an event which is stored in our unfiltered timeline set, or in a thread
      *

src/sync.ts

@@ -77,6 +77,13 @@ export enum SyncState {
     Reconnecting = "RECONNECTING",
 }
 
+// Room versions where "insertion", "batch", and "marker" events are controlled
+// by power-levels. MSC2716 is supported in existing room versions but they
+// should only have special meaning when the room creator sends them.
+const MSC2716_ROOM_VERSIONS = [
+    'org.matrix.msc2716v3'
+];
+
 function getFilterName(userId: string, suffix?: string): string {
     // scope this on the user ID because people may login on many accounts
     // and they all need to be stored!
@@ -239,6 +246,27 @@ export class SyncApi {
                 RoomMemberEvent.Membership,
             ]);
         });
+
+        room.currentState.on(RoomStateEvent.Marker, function(event, state) {
+            const isValidMsc2716Event =  MSC2716_ROOM_VERSIONS.includes(room.getVersion()) ||
+                // MSC2716 is supported in all existing room versions but special
+                // meaning should only be given to "insertion", "batch", and
+                // "marker" events when they come from the room creator
+                event.getSender() === room.getRoomCreator();
+            console.log(`On marker state isValidMsc2716Event=${isValidMsc2716Event}, event_id=${event.getId()} room.getLastMarkerEventIdProcessed()=${room.getLastMarkerEventIdProcessed()}`);
+            if(
+                isValidMsc2716Event &&
+                // We only need to throw the timeline away once when we see a
+                // marker. All of the historical content will be in the
+                // `/messsages` responses from here on out.
+                event.getId() !== room.getLastMarkerEventIdProcessed()
+            ) {
+                // Saw new marker event, refreshing the timeline
+                console.log('Saw new marker event, refreshing the timeline');
+                room.resetLiveTimeline(null, null);
+                room.setLastMarkerEventIdProcessed(event.getId())
+            }
+        });
     }
 
     /**
@@ -250,6 +278,7 @@ export class SyncApi {
         room.currentState.removeAllListeners(RoomStateEvent.Events);
         room.currentState.removeAllListeners(RoomStateEvent.Members);
         room.currentState.removeAllListeners(RoomStateEvent.NewMember);
+        room.currentState.removeAllListeners(RoomStateEvent.Marker);
     }
 
     /**