From bea9d83079002ed5c6b2439738d8272dfe77fa74 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 16 Mar 2022 13:01:09 +0000
Subject: [PATCH 01/81] Add labs flag for sliding sync; add
 sliding_sync_proxy_url to config.json

---
 src/SdkConfig.ts                                          | 2 ++
 .../views/settings/tabs/user/LabsUserSettingsTab.tsx      | 8 ++++++++
 src/i18n/strings/en_EN.json                               | 1 +
 src/rageshake/submit-rageshake.ts                         | 4 ++++
 src/sentry.ts                                             | 2 ++
 src/settings/Settings.tsx                                 | 6 ++++++
 6 files changed, 23 insertions(+)

diff --git a/src/SdkConfig.ts b/src/SdkConfig.ts
index c4387d1f237..95183916012 100644
--- a/src/SdkConfig.ts
+++ b/src/SdkConfig.ts
@@ -43,6 +43,8 @@ export const DEFAULTS: ConfigOptions = {
     integrations_rest_url: "https://scalar.vector.im/api",
     // Where to send bug reports. If not specified, bugs cannot be sent.
     bug_report_endpoint_url: null,
+    // The location of the sliding sync proxy. If not specified, sliding sync mode cannot be enabled.
+    sliding_sync_proxy_url: null,
     // Jitsi conference options
     jitsi: {
         // Default conference domain
diff --git a/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx b/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx
index a7c7f4df497..6ec3488cf32 100644
--- a/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx
+++ b/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx
@@ -110,6 +110,14 @@ export default class LabsUserSettingsTab extends React.Component<{}, IState> {
                 />,
             );
 
+            groups.getOrCreate(LabGroup.Experimental, []).push(
+                <SettingsFlag
+                    key="slidingSync"
+                    name="slidingSync"
+                    level={SettingLevel.DEVICE}
+                />,
+            );
+
             groups.getOrCreate(LabGroup.Developer, []).push(
                 <SettingsFlag
                     key="developerMode"
diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json
index abb355d7d84..76954e9445f 100644
--- a/src/i18n/strings/en_EN.json
+++ b/src/i18n/strings/en_EN.json
@@ -953,6 +953,7 @@
     "Show shortcuts to recently viewed rooms above the room list": "Show shortcuts to recently viewed rooms above the room list",
     "Show hidden events in timeline": "Show hidden events in timeline",
     "Low bandwidth mode (requires compatible homeserver)": "Low bandwidth mode (requires compatible homeserver)",
+    "Sliding Sync mode (requires proxy, set via \"sliding_sync_proxy_url\" in config.json)": "Sliding Sync mode (requires proxy, set via \"sliding_sync_proxy_url\" in config.json)",
     "Allow fallback call assist server turn.matrix.org when your homeserver does not offer one (your IP address would be shared during a call)": "Allow fallback call assist server turn.matrix.org when your homeserver does not offer one (your IP address would be shared during a call)",
     "Show previews/thumbnails for images": "Show previews/thumbnails for images",
     "Enable message search in encrypted rooms": "Enable message search in encrypted rooms",
diff --git a/src/rageshake/submit-rageshake.ts b/src/rageshake/submit-rageshake.ts
index 4822a9039c4..b9844cb0d26 100644
--- a/src/rageshake/submit-rageshake.ts
+++ b/src/rageshake/submit-rageshake.ts
@@ -137,6 +137,10 @@ async function collectBugReport(opts: IOpts = {}, gzipLogs = true) {
         body.append("lowBandwidth", "enabled");
     }
 
+    if (SettingsStore.getValue("slidingSync")) {
+        body.append("slidingSync", "enabled");
+    }
+
     // add storage persistence/quota information
     if (navigator.storage && navigator.storage.persisted) {
         try {
diff --git a/src/sentry.ts b/src/sentry.ts
index 4fdcd95635e..cad161b256f 100644
--- a/src/sentry.ts
+++ b/src/sentry.ts
@@ -34,6 +34,7 @@ type UserContext = {
     username: string;
     enabled_labs: string;
     low_bandwidth: string;
+    sliding_sync: string;
 };
 
 type CryptoContext = {
@@ -102,6 +103,7 @@ function getUserContext(client: MatrixClient): UserContext {
         "username": client.credentials.userId,
         "enabled_labs": getEnabledLabs(),
         "low_bandwidth": SettingsStore.getValue("lowBandwidth") ? "enabled" : "disabled",
+        "sliding_sync": SettingsStore.getValue("slidingSync") ? "enabled" : "disabled",
     };
 }
 
diff --git a/src/settings/Settings.tsx b/src/settings/Settings.tsx
index b1fb6a86063..0f5d5617579 100644
--- a/src/settings/Settings.tsx
+++ b/src/settings/Settings.tsx
@@ -795,6 +795,12 @@ export const SETTINGS: {[setting: string]: ISetting} = {
         default: false,
         controller: new ReloadOnChangeController(),
     },
+    "slidingSync": {
+        supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
+        displayName: _td('Sliding Sync mode (requires proxy, set via "sliding_sync_proxy_url" in config.json)'),
+        default: false,
+        controller: new ReloadOnChangeController(),
+    },
     "fallbackICEServerAllowed": {
         supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS,
         displayName: _td(

From 7fb8656cb7ce2032685491c524bf77ab82f6535a Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 16 Mar 2022 13:05:05 +0000
Subject: [PATCH 02/81] Disable the labs toggle if sliding_sync_proxy_url is
 not set

---
 src/settings/Settings.tsx                     |  3 +-
 .../controllers/SlidingSyncController.ts      | 30 +++++++++++++++++++
 2 files changed, 32 insertions(+), 1 deletion(-)
 create mode 100644 src/settings/controllers/SlidingSyncController.ts

diff --git a/src/settings/Settings.tsx b/src/settings/Settings.tsx
index 0f5d5617579..a8b5d959bb5 100644
--- a/src/settings/Settings.tsx
+++ b/src/settings/Settings.tsx
@@ -42,6 +42,7 @@ import IncompatibleController from "./controllers/IncompatibleController";
 import { ImageSize } from "./enums/ImageSize";
 import { MetaSpace } from "../stores/spaces";
 import SdkConfig from "../SdkConfig";
+import SlidingSyncController from './controllers/SlidingSyncController';
 
 // These are just a bunch of helper arrays to avoid copy/pasting a bunch of times
 const LEVELS_ROOM_SETTINGS = [
@@ -799,7 +800,7 @@ export const SETTINGS: {[setting: string]: ISetting} = {
         supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
         displayName: _td('Sliding Sync mode (requires proxy, set via "sliding_sync_proxy_url" in config.json)'),
         default: false,
-        controller: new ReloadOnChangeController(),
+        controller: new SlidingSyncController(),
     },
     "fallbackICEServerAllowed": {
         supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS,
diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
new file mode 100644
index 00000000000..bbb3398b824
--- /dev/null
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -0,0 +1,30 @@
+/*
+Copyright 2019, 2020 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import SettingController from "./SettingController";
+import PlatformPeg from "../../PlatformPeg";
+import { SettingLevel } from "../SettingLevel";
+import SdkConfig from "../../SdkConfig";
+
+export default class SlidingSyncController extends SettingController {
+    public onChange(level: SettingLevel, roomId: string, newValue: any) {
+        PlatformPeg.get().reload();
+    }
+
+    public get settingDisabled(): boolean {
+        return !SdkConfig.get().sliding_sync_proxy_url;
+    }
+}

From c735976570ac39e4b8ba36cc5c64c8ed1cabc524 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 16 Mar 2022 15:06:05 +0000
Subject: [PATCH 03/81] Do validation checks on the sliding sync proxy URL
 before enabling it in Labs

---
 .../controllers/SlidingSyncController.ts      | 56 ++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)

diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
index bbb3398b824..99344d78a6d 100644
--- a/src/settings/controllers/SlidingSyncController.ts
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -18,9 +18,29 @@ import SettingController from "./SettingController";
 import PlatformPeg from "../../PlatformPeg";
 import { SettingLevel } from "../SettingLevel";
 import SdkConfig from "../../SdkConfig";
+import { logger } from "matrix-js-sdk/src/logger";
+import SettingsStore from "../SettingsStore";
 
 export default class SlidingSyncController extends SettingController {
-    public onChange(level: SettingLevel, roomId: string, newValue: any) {
+
+    public async onChange(level: SettingLevel, roomId: string, newValue: any) {
+        if (newValue) {
+            // run checks against the "proxy" to make sure it is valid BEFORE we start doing things
+            const url = SdkConfig.get().sliding_sync_proxy_url;
+            if (!url) {
+                logger.error("cannot enable sliding sync without 'sliding_sync_proxy_url' being present");
+                return;
+            }
+            try {
+                await proxyHealthCheck(url);
+            } catch (err) {
+                console.error(err);
+                // force the value to false, this is a bit ew, it would be nice if we could return
+                // a bool as to whether to go through with the change or not.
+                SettingsStore.setValue("slidingSync", roomId, level, false);
+                return;
+            }
+        }
         PlatformPeg.get().reload();
     }
 
@@ -28,3 +48,37 @@ export default class SlidingSyncController extends SettingController {
         return !SdkConfig.get().sliding_sync_proxy_url;
     }
 }
+
+/**
+ * Check that the proxy url is in fact a sliding sync proxy endpoint and it is up.
+ * @param endpoint The proxy endpoint url
+ * @param hsUrl The homeserver url of the logged in user. 
+ * @returns True if the proxy is valid, else throws.
+ */
+function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<boolean> {
+    // TODO: when HSes natively support sliding sync, we should just hit the /sync endpoint to see
+    // if it 200 OKs.
+    return new Promise<boolean>((resolve, reject) => {
+        const req = new XMLHttpRequest();
+        req.open("GET", endpoint + "/client/server.json");
+        req.responseType = "json";
+        req.timeout = 10 * 1000;
+        req.onreadystatechange = function() {
+            if (req.readyState !== XMLHttpRequest.DONE) {
+                return;
+            }
+            if (req.status !== 200) {
+                reject(new Error(`HTTP ${req.status}`));
+                return;
+            }
+            // The proxy is hard-coded on startup to talk to a single HS. Make sure that HS matches
+            // the client's HS else we might give an access_token to a different homeserver!
+            if (hsUrl && hsUrl !== req.response.server) {
+                reject(new Error("homeserver mismatch: client="+hsUrl+" proxy="+req.response.server));
+                return;
+            }
+            resolve(true);
+        };
+        req.send();
+    });
+}
\ No newline at end of file

From bddf053125d714bbc52320beea3cd2a821ac5c55 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 17 Mar 2022 11:51:13 +0000
Subject: [PATCH 04/81] Enable sliding sync and add SlidingSyncManager

---
 src/MatrixClientPeg.ts    |  9 ++++
 src/SlidingSyncManager.ts | 99 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 108 insertions(+)
 create mode 100644 src/SlidingSyncManager.ts

diff --git a/src/MatrixClientPeg.ts b/src/MatrixClientPeg.ts
index c8502b0795e..8d6c6a5bff8 100644
--- a/src/MatrixClientPeg.ts
+++ b/src/MatrixClientPeg.ts
@@ -37,6 +37,8 @@ import * as StorageManager from './utils/StorageManager';
 import IdentityAuthClient from './IdentityAuthClient';
 import { crossSigningCallbacks, tryToUnlockSecretStorageWithDehydrationKey } from './SecurityManager';
 import SecurityCustomisations from "./customisations/Security";
+import SdkConfig from './SdkConfig';
+import * as SlidingSyncManager from './SlidingSyncManager';
 
 export interface IMatrixClientCreds {
     homeserverUrl: string;
@@ -217,6 +219,13 @@ class MatrixClientPegClass implements IMatrixClientPeg {
         opts.clientWellKnownPollPeriod = 2 * 60 * 60; // 2 hours
         opts.experimentalThreadSupport = SettingsStore.getValue("feature_thread");
 
+        if (SettingsStore.getValue("slidingSync") && SdkConfig.get().sliding_sync_proxy_url) {
+            logger.log("Activating sliding sync using proxy at ", SdkConfig.get().sliding_sync_proxy_url);
+            opts.slidingSync = SlidingSyncManager.create(
+                this.matrixClient, SdkConfig.get().sliding_sync_proxy_url,
+            );
+        }
+
         // Connect the matrix client to the dispatcher and setting handlers
         MatrixActionCreators.start(this.matrixClient);
         MatrixClientBackedSettingsHandler.matrixClient = this.matrixClient;
diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
new file mode 100644
index 00000000000..971b269b10c
--- /dev/null
+++ b/src/SlidingSyncManager.ts
@@ -0,0 +1,99 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+/*
+ * Sliding Sync Architecture - MSC https://github.com/matrix-org/matrix-spec-proposals/pull/3575
+ * 
+ * This is a holistic summary of the changes made to Element-Web / React SDK / JS SDK to enable sliding sync.
+ * This summary will hopefully signpost where developers need to look if they want to make changes to this code.
+ * 
+ * At the lowest level, the JS SDK contains an HTTP API wrapper function in client.ts. This is used by
+ * a SlidingSync class in JS SDK, which contains code to handle list operations (INSERT/DELETE/SYNC/etc)
+ * and contains the main request API bodies, but has no code to control updating JS SDK structures: it just
+ * exposes an EventEmitter to listen for updates. When MatrixClient.startClient is called, callers need to
+ * provide a SlidingSync instance as this contains the main request API params (timeline limit, required state,
+ * how many lists, etc).
+ * 
+ * The SlidingSyncSdk INTERNAL class in JS SDK attaches listeners to SlidingSync to update JS SDK Room objects,
+ * and it conveniently exposes an identical public API to SyncApi (to allow it to be a drop-in replacement).
+ * 
+ * At the highest level, SlidingSyncManager contains mechanisms to tell UI lists which rooms to show,
+ * and contains the core request API params used in Element-Web. It does this by listening for events
+ * emitted by the SlidingSync class and by modifying the request API params on the SlidingSync class.
+ * 
+ *    (entry point)                     (updates JS SDK)
+ *  SlidingSyncManager                   SlidingSyncSdk
+ *       |                                     |
+ *       +------------------.------------------+
+ *         listens          |          listens
+ *                     SlidingSync
+ *                     (sync loop,
+ *                      list ops)
+ */
+
+import { MatrixClient } from 'matrix-js-sdk';
+import { SlidingSync } from 'matrix-js-sdk/src/sliding-sync';
+
+// how long to long poll for
+const SLIDING_SYNC_TIMEOUT_MS = 20 * 1000;
+
+// the things to fetch when a user clicks on a room
+const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
+    timeline_limit: 50,
+    required_state: [
+        ["*", "*"], // all events
+    ]
+};
+
+/**
+ * This class manages the entirety of sliding sync at a high UI/UX level. It controls the placement
+ * of placeholders in lists, controls updating sliding window ranges, and controls which events
+ * are pulled down when. The intention behind this manager is be the single place to look for sliding
+ * sync options and code.
+ */
+export class SlidingSyncManager {
+    slidingSync: SlidingSync;
+
+    constructor(client: MatrixClient, proxyUrl: string){
+        this.slidingSync = new SlidingSync(proxyUrl, [], DEFAULT_ROOM_SUBSCRIPTION_INFO, client, SLIDING_SYNC_TIMEOUT_MS);
+    }
+
+};
+
+let manager = null;
+export function get(): SlidingSyncManager {
+    return manager;
+}
+export function create(client: MatrixClient, proxyUrl: string): SlidingSync {
+    // TODO: unregister existing callbacks?
+    manager = new SlidingSyncManager(client, proxyUrl);
+    manager.slidingSync.setList(0, {
+        ranges: [ [0, 20] ],
+        sort: [
+            "by_highlight_count", "by_notification_count", "by_recency",
+        ],
+        timeline_limit: 1, // most recent message display: though this seems to only be needed for favourites?
+        required_state: [
+            ["m.room.join_rules", ""], // the public icon on the room list
+            ["m.room.avatar", ""], // any room avatar
+            ["m.room.tombstone", ""], // lets JS SDK hide rooms which are dead
+            ["m.room.encryption", ""], // lets rooms be configured for E2EE correctly
+            ["m.room.member", client.getUserId()], // lets the client calculate that we are in fact in the room
+        ]
+    });
+    return manager.slidingSync;
+}
\ No newline at end of file

From eb76ff439cb3b1fd119067565c74e3e0112569cf Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 17 Mar 2022 15:50:06 +0000
Subject: [PATCH 05/81] Get room subscriptions working

---
 src/SlidingSyncManager.ts              | 29 ++++++++++++++++++++++++--
 src/components/structures/RoomView.tsx | 11 ++++++++++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 971b269b10c..0f8298ebfdd 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -46,7 +46,8 @@ limitations under the License.
  */
 
 import { MatrixClient } from 'matrix-js-sdk';
-import { SlidingSync } from 'matrix-js-sdk/src/sliding-sync';
+import { SlidingSync, SlidingSyncEvent, SlidingSyncState } from 'matrix-js-sdk/src/sliding-sync';
+import { logger } from "matrix-js-sdk/src/logger";
 
 // how long to long poll for
 const SLIDING_SYNC_TIMEOUT_MS = 20 * 1000;
@@ -72,10 +73,33 @@ export class SlidingSyncManager {
         this.slidingSync = new SlidingSync(proxyUrl, [], DEFAULT_ROOM_SUBSCRIPTION_INFO, client, SLIDING_SYNC_TIMEOUT_MS);
     }
 
+
+    setRoomVisible(roomId: string, visible: boolean): Promise<string> {
+        let subscriptions = this.slidingSync.getRoomSubscriptions();
+        if (visible) {
+            subscriptions.add(roomId);
+        } else {
+            subscriptions.delete(roomId);
+        }
+        logger.log("SlidingSync setRoomVisible:",roomId, visible);
+        this.slidingSync.modifyRoomSubscriptions(subscriptions);
+
+        return new Promise((resolve, reject) => {
+            const resolveOnSubscribed = (state, resp, err) => {
+                if (state === SlidingSyncState.Complete) { // we processed a /sync response
+                    this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
+                    resolve(roomId);
+                }
+            };
+            // wait until the next sync before returning as RoomView may need to know the current state
+            this.slidingSync.on(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
+        });
+    }
+
 };
 
 let manager = null;
-export function get(): SlidingSyncManager {
+export function getSlidingSyncManager(): SlidingSyncManager {
     return manager;
 }
 export function create(client: MatrixClient, proxyUrl: string): SlidingSync {
@@ -92,6 +116,7 @@ export function create(client: MatrixClient, proxyUrl: string): SlidingSync {
             ["m.room.avatar", ""], // any room avatar
             ["m.room.tombstone", ""], // lets JS SDK hide rooms which are dead
             ["m.room.encryption", ""], // lets rooms be configured for E2EE correctly
+            ["m.room.create", ""], // for isSpaceRoom checks
             ["m.room.member", client.getUserId()], // lets the client calculate that we are in fact in the room
         ]
     });
diff --git a/src/components/structures/RoomView.tsx b/src/components/structures/RoomView.tsx
index b6591bc2b7e..e7bb9fc9f1b 100644
--- a/src/components/structures/RoomView.tsx
+++ b/src/components/structures/RoomView.tsx
@@ -108,6 +108,7 @@ import { DoAfterSyncPreparedPayload } from '../../dispatcher/payloads/DoAfterSyn
 import FileDropTarget from './FileDropTarget';
 import Measured from '../views/elements/Measured';
 import { FocusComposerPayload } from '../../dispatcher/payloads/FocusComposerPayload';
+import { getSlidingSyncManager, SlidingSyncManager } from '../../SlidingSyncManager';
 
 const DEBUG = false;
 let debuglog = function(msg: string) {};
@@ -393,6 +394,11 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
         }
 
         const roomId = RoomViewStore.getRoomId();
+        if (initial && SettingsStore.getValue("slidingSync")) {
+            // set this room as the room subscription. We need to await for it as this will fetch
+            // all room state for this room, which is required before we get the state below.
+           await getSlidingSyncManager().setRoomVisible(roomId, true);
+        }
 
         const newState: Pick<IRoomState, any> = {
             roomId,
@@ -698,6 +704,11 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
             this.context.stopPeeking();
         }
 
+        if (SettingsStore.getValue("slidingSync")) {
+            // unsubscribe from this room, but don't await it as we don't care when this gets done.
+            getSlidingSyncManager().setRoomVisible(this.state.roomId, false);
+        }
+
         // stop tracking room changes to format permalinks
         this.stopAllPermalinkCreators();
 

From 9b59f05494f785f07a507e90e429bc3fed722221 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 18 Mar 2022 17:24:00 +0000
Subject: [PATCH 06/81] Hijack renderSublists in sliding sync mode

---
 src/components/views/rooms/RoomList.tsx    | 42 ++++++++++++++++++++++
 src/components/views/rooms/RoomSublist.tsx |  1 +
 2 files changed, 43 insertions(+)

diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index 36284a47b41..5fed19d42ff 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -597,6 +597,9 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
     }
 
     private renderSublists(): React.ReactElement[] {
+        if (SettingsStore.getValue("slidingSync")) {
+            return this.renderSlidingSyncLists();
+        }
         // show a skeleton UI if the user is in no rooms and they are not filtering and have no suggested rooms
         const showSkeleton = !this.state.isNameFiltering && !this.state.suggestedRooms?.length &&
             Object.values(RoomListStore.instance.unfilteredLists).every(list => !list?.length);
@@ -665,6 +668,45 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
             });
     }
 
+    private renderSlidingSyncLists(): React.ReactElement[] {
+        const tagOrder = [
+            DefaultTagID.Invite,
+            // DefaultTagID.Favourite,
+            DefaultTagID.DM,
+            DefaultTagID.Untagged,
+        ];
+        const tagToSlidingSyncFilters = {
+            [DefaultTagID.Invite]: {
+                is_invite: true,
+            },
+            [DefaultTagID.DM]: {
+                is_dm: true,
+            },
+            [DefaultTagID.Untagged]: {
+                is_invite: false,
+                is_dm: false,
+            },
+        };
+        return tagOrder.map((tag) => {
+            const aesthetics = TAG_AESTHETICS[tag];
+            return <RoomSublist
+                key={`sublist-${tag}`}
+                tagId={tag}
+                forRooms={true}
+                slidingSyncFilter={tagToSlidingSyncFilters[tag]}
+                startAsHidden={aesthetics.defaultHidden}
+                label={aesthetics.sectionLabelRaw ? aesthetics.sectionLabelRaw : _t(aesthetics.sectionLabel)}
+                AuxButtonComponent={aesthetics.AuxButtonComponent}
+                isMinimized={this.props.isMinimized}
+                extraTiles={null}
+                resizeNotifier={this.props.resizeNotifier}
+                alwaysVisible={false}
+                onListCollapse={this.props.onListCollapse}
+                forceExpanded={false}
+            />;
+        })
+    }
+
     public focus(): void {
         // focus the first focusable element in this aria treeview widget
         const treeItems = this.treeRef.current?.querySelectorAll<HTMLElement>('[role="treeitem"]');
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 3f03d11a76c..37f9f2b6d8d 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -84,6 +84,7 @@ interface IProps {
     forceExpanded?: boolean;
     resizeNotifier: ResizeNotifier;
     extraTiles?: ReactComponentElement<typeof ExtraTile>[];
+    slidingSyncFilter?: object; // request JSON for the 'filters' object.
     onListCollapse?: (isExpanded: boolean) => void;
 }
 

From e75b48ae699e592c8ffd6a392d7d8e35ca0f54bc Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 21 Mar 2022 17:39:04 +0000
Subject: [PATCH 07/81] Add support for sorting alphabetically/recency and room
 name filters

---
 src/SlidingSyncManager.ts                  |  67 +++++++++---
 src/components/views/rooms/RoomList.tsx    |   3 +-
 src/components/views/rooms/RoomSublist.tsx | 118 +++++++++++++++++++--
 3 files changed, 162 insertions(+), 26 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 0f8298ebfdd..3d53ce9fcd7 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -46,7 +46,7 @@ limitations under the License.
  */
 
 import { MatrixClient } from 'matrix-js-sdk';
-import { SlidingSync, SlidingSyncEvent, SlidingSyncState } from 'matrix-js-sdk/src/sliding-sync';
+import { MSC3575List, SlidingSync, SlidingSyncEvent, SlidingSyncState } from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";
 
 // how long to long poll for
@@ -68,11 +68,60 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
  */
 export class SlidingSyncManager {
     slidingSync: SlidingSync;
+    client: MatrixClient;
 
     constructor(client: MatrixClient, proxyUrl: string){
         this.slidingSync = new SlidingSync(proxyUrl, [], DEFAULT_ROOM_SUBSCRIPTION_INFO, client, SLIDING_SYNC_TIMEOUT_MS);
+        this.client = client;
     }
 
+    /**
+     * Ensure that this list is registered.
+     * @param listIndex The list index to register
+     * @param updateArgs The fields to update on the list.
+     * @returns The complete list request params
+     */
+    async ensureListRegistered(listIndex: number, updateArgs: { filters?: object, sort?: string[], ranges?: number[][] }): Promise<MSC3575List> {
+        console.log("ensureListRegistered", listIndex, updateArgs);
+        let list = this.slidingSync.getList(listIndex);
+        if (!list) {
+            list = {
+                ranges: [ [0, 20] ],
+                sort: [
+                    "by_highlight_count", "by_notification_count", "by_recency",
+                ],
+                timeline_limit: 1, // most recent message display: though this seems to only be needed for favourites?
+                required_state: [
+                    ["m.room.join_rules", ""], // the public icon on the room list
+                    ["m.room.avatar", ""], // any room avatar
+                    ["m.room.tombstone", ""], // lets JS SDK hide rooms which are dead
+                    ["m.room.encryption", ""], // lets rooms be configured for E2EE correctly
+                    ["m.room.create", ""], // for isSpaceRoom checks
+                    ["m.room.member", this.client.getUserId()], // lets the client calculate that we are in fact in the room
+                ]
+            };
+            list = Object.assign(list, updateArgs);
+        } else {
+            const updatedList = Object.assign({}, list, updateArgs);
+            if (JSON.stringify(list) === JSON.stringify(updatedList)) {
+                console.log("list matches, not sending, update => ", updateArgs);
+                return list;
+            }
+            list = updatedList;
+        }
+        this.slidingSync.setList(listIndex, list);
+
+        return new Promise((resolve, reject) => {
+            const resolveOnSubscribed = (state, resp, err) => {
+                if (state === SlidingSyncState.Complete) { // we processed a /sync response
+                    this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
+                    resolve(list);
+                }
+            };
+            // wait until the next sync before returning as RoomView may need to know the current state
+            this.slidingSync.on(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
+        });
+    }
 
     setRoomVisible(roomId: string, visible: boolean): Promise<string> {
         let subscriptions = this.slidingSync.getRoomSubscriptions();
@@ -103,22 +152,6 @@ export function getSlidingSyncManager(): SlidingSyncManager {
     return manager;
 }
 export function create(client: MatrixClient, proxyUrl: string): SlidingSync {
-    // TODO: unregister existing callbacks?
     manager = new SlidingSyncManager(client, proxyUrl);
-    manager.slidingSync.setList(0, {
-        ranges: [ [0, 20] ],
-        sort: [
-            "by_highlight_count", "by_notification_count", "by_recency",
-        ],
-        timeline_limit: 1, // most recent message display: though this seems to only be needed for favourites?
-        required_state: [
-            ["m.room.join_rules", ""], // the public icon on the room list
-            ["m.room.avatar", ""], // any room avatar
-            ["m.room.tombstone", ""], // lets JS SDK hide rooms which are dead
-            ["m.room.encryption", ""], // lets rooms be configured for E2EE correctly
-            ["m.room.create", ""], // for isSpaceRoom checks
-            ["m.room.member", client.getUserId()], // lets the client calculate that we are in fact in the room
-        ]
-    });
     return manager.slidingSync;
 }
\ No newline at end of file
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index 5fed19d42ff..101242b2385 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -687,13 +687,14 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
                 is_dm: false,
             },
         };
-        return tagOrder.map((tag) => {
+        return tagOrder.map((tag, index) => {
             const aesthetics = TAG_AESTHETICS[tag];
             return <RoomSublist
                 key={`sublist-${tag}`}
                 tagId={tag}
                 forRooms={true}
                 slidingSyncFilter={tagToSlidingSyncFilters[tag]}
+                slidingSyncIndex={index}
                 startAsHidden={aesthetics.defaultHidden}
                 label={aesthetics.sectionLabelRaw ? aesthetics.sectionLabelRaw : _t(aesthetics.sectionLabel)}
                 AuxButtonComponent={aesthetics.AuxButtonComponent}
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 37f9f2b6d8d..029c096d66d 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -57,6 +57,10 @@ import { getKeyBindingsManager } from "../../../KeyBindingsManager";
 import { replaceableComponent } from "../../../utils/replaceableComponent";
 import { KeyBindingAction } from "../../../accessibility/KeyboardShortcuts";
 import { ViewRoomPayload } from "../../../dispatcher/payloads/ViewRoomPayload";
+import SettingsStore from "../../../settings/SettingsStore";
+import { getSlidingSyncManager, SlidingSyncManager } from "../../../SlidingSyncManager";
+import { SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
+import { MatrixClientPeg } from "../../../MatrixClientPeg";
 
 const SHOW_N_BUTTON_HEIGHT = 28; // As defined by CSS
 const RESIZE_HANDLE_HEIGHT = 4; // As defined by CSS
@@ -72,6 +76,12 @@ export interface IAuxButtonProps {
     dispatcher?: Dispatcher<ActionPayload>;
 }
 
+const SlidingSyncSortToFilter: Record<SortAlgorithm, string[]> = {
+    [SortAlgorithm.Alphabetic]: ["by_name", "by_recency"],
+    [SortAlgorithm.Recent]: ["by_highlight_count", "by_notification_count", "by_recency"],
+    [SortAlgorithm.Manual]: ["by_recency"],
+};
+
 interface IProps {
     forRooms: boolean;
     startAsHidden: boolean;
@@ -85,6 +95,7 @@ interface IProps {
     resizeNotifier: ResizeNotifier;
     extraTiles?: ReactComponentElement<typeof ExtraTile>[];
     slidingSyncFilter?: object; // request JSON for the 'filters' object.
+    slidingSyncIndex?: number; // the list index for this sublist
     onListCollapse?: (isExpanded: boolean) => void;
 }
 
@@ -116,8 +127,20 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     private isBeingFiltered: boolean;
     private notificationState: ListNotificationState;
 
+    private slidingSyncMode: boolean;
+    private slidingSyncInit: Promise<any>;
+
     constructor(props: IProps) {
         super(props);
+        // when this setting is toggled it restarts the app so it's safe to not watch this.
+        this.slidingSyncMode = SettingsStore.getValue("slidingSync");
+        if (this.slidingSyncMode) {
+            this.onSlidingSyncListUpdate = this.onSlidingSyncListUpdate.bind(this);
+            this.slidingSyncInit = getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
+                filters: this.props.slidingSyncFilter,
+                sort: SlidingSyncSortToFilter[SortAlgorithm.Recent], // default to recency sort
+            });
+        }
 
         this.layout = RoomListLayoutStore.instance.getLayoutFor(this.props.tagId);
         this.heightAtStart = 0;
@@ -128,7 +151,8 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             isResizing: false,
             isExpanded: this.isBeingFiltered ? this.isBeingFiltered : !this.layout.isCollapsed,
             height: 0, // to be fixed in a moment, we need `rooms` to calculate this.
-            rooms: arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || []),
+            // sliding sync mode has no rooms initially as we need to fetch them via a request
+            rooms: this.slidingSyncMode ? [] : arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || []),
         };
         // Why Object.assign() and not this.state.height? Because TypeScript says no.
         this.state = Object.assign(this.state, { height: this.calculateInitialHeight() });
@@ -247,9 +271,19 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         return false;
     }
 
-    public componentDidMount() {
+    public async componentDidMount() {
+        await this.slidingSyncInit;
+
         this.dispatcherRef = defaultDispatcher.register(this.onAction);
         RoomListStore.instance.on(LISTS_UPDATE_EVENT, this.onListsUpdated);
+        if (this.slidingSyncMode) {
+            // listen for updates to this list
+            getSlidingSyncManager().slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
+            // fire the list data for the initial render
+            const listData = getSlidingSyncManager().slidingSync.getListData(this.props.slidingSyncIndex);
+            this.onSlidingSyncListUpdate(this.props.slidingSyncIndex, listData.joinedCount, listData.roomIndexToRoomId);
+        }
+
         // Using the passive option to not block the main thread
         // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#improving_scrolling_performance_with_passive_listeners
         this.tilesRef.current?.addEventListener("scroll", this.onScrollPrevent, { passive: true });
@@ -257,10 +291,33 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
     public componentWillUnmount() {
         defaultDispatcher.unregister(this.dispatcherRef);
+        if (this.slidingSyncMode) {
+            getSlidingSyncManager().slidingSync.off(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
+        }
         RoomListStore.instance.off(LISTS_UPDATE_EVENT, this.onListsUpdated);
         this.tilesRef.current?.removeEventListener("scroll", this.onScrollPrevent);
     }
 
+    private onSlidingSyncListUpdate(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>) {
+        if (listIndex !== this.props.slidingSyncIndex) {
+            return;
+        }
+        const orderedRoomIds = Object.keys(roomIndexToRoomId).map((numStr) => {
+            return Number(numStr);
+        }).sort().map((i) => {
+            return roomIndexToRoomId[i];
+        });
+
+        console.log("onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:", orderedRoomIds);
+
+        // now set the rooms
+        this.setState({
+            rooms: orderedRoomIds.map((roomId) => {
+                return MatrixClientPeg.get().getRoom(roomId);
+            }),
+        });
+    }
+
     private onListsUpdated = () => {
         const stateUpdates: IState & any = {}; // &any is to avoid a cast on the initializer
 
@@ -274,10 +331,25 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             }
         }
 
-        const currentRooms = this.state.rooms;
-        const newRooms = arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || []);
-        if (arrayHasOrderChange(currentRooms, newRooms)) {
-            stateUpdates.rooms = newRooms;
+        // send up room name filters to sliding sync
+        if (this.slidingSyncMode) {
+            const nameCondition = RoomListStore.instance.getFirstNameFilterCondition();
+            if (nameCondition) {
+                // add the name condition to the existing filters for this list.
+                const newFilters = Object.assign({
+                    room_name_like: nameCondition.search,
+                }, this.props.slidingSyncFilter);
+                // send the new filters up, but don't await it as we'll get poked via onSlidingSyncListUpdate 
+                getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
+                    filters: newFilters,
+                });
+            }
+        } else { // don't update rooms in sliding sync mode, it handles all that.
+            const currentRooms = this.state.rooms;
+            const newRooms = arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || []);
+            if (arrayHasOrderChange(currentRooms, newRooms)) {
+                stateUpdates.rooms = newRooms;
+            }
         }
 
         const isStillBeingFiltered = !!RoomListStore.instance.getFirstNameFilterCondition();
@@ -403,6 +475,31 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     };
 
     private onTagSortChanged = async (sort: SortAlgorithm) => {
+        if (this.slidingSyncMode) {
+            switch (sort) {
+                case SortAlgorithm.Alphabetic:
+                    await getSlidingSyncManager().ensureListRegistered(
+                        this.props.slidingSyncIndex, {
+                            sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic]
+                        },
+                    );
+                    break;
+                case SortAlgorithm.Recent:
+                    await getSlidingSyncManager().ensureListRegistered(
+                        this.props.slidingSyncIndex, {
+                            sort: SlidingSyncSortToFilter[SortAlgorithm.Recent],
+                        },
+                    );
+                    break;
+                case SortAlgorithm.Manual:
+                    console.error("cannot enable manual sort in sliding sync mode");
+                    break;
+                default:
+                    console.error("unknown sort mode: ", sort);
+            }
+            // no need for forceUpdate here as the /sync response will fire onSlidingSyncListUpdate
+            return;
+        } 
         await RoomListStore.instance.setTagSorting(this.props.tagId, sort);
         this.forceUpdate();
     };
@@ -562,8 +659,13 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
         let contextMenu = null;
         if (this.state.contextMenuPosition) {
-            const isAlphabetical = RoomListStore.instance.getTagSorting(this.props.tagId) === SortAlgorithm.Alphabetic;
-            const isUnreadFirst = RoomListStore.instance.getListOrder(this.props.tagId) === ListAlgorithm.Importance;
+            let isAlphabetical = RoomListStore.instance.getTagSorting(this.props.tagId) === SortAlgorithm.Alphabetic;
+            let isUnreadFirst = RoomListStore.instance.getListOrder(this.props.tagId) === ListAlgorithm.Importance;
+            if (this.slidingSyncMode) {
+                const slidingList = getSlidingSyncManager().slidingSync.getList(this.props.slidingSyncIndex);
+                isAlphabetical = slidingList.sort[0] === "by_name";
+                isUnreadFirst = slidingList.sort[0] === "by_highlight_count" || slidingList.sort[0] === "by_unread_count";
+            }
 
             // Invites don't get some nonsense options, so only add them if we have to.
             let otherSections = null;

From 18cd70b2d2992583efcbc2d91c883be1479719ca Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 22 Mar 2022 17:58:33 +0000
Subject: [PATCH 08/81] Filter out tombstoned rooms; start adding show more
 logic

list ranges update but the UI doesn't
---
 src/SlidingSyncManager.ts                  | 14 ++++++-
 src/components/structures/RoomView.tsx     |  2 +-
 src/components/views/rooms/RoomList.tsx    |  5 ++-
 src/components/views/rooms/RoomSublist.tsx | 48 ++++++++++++++++++----
 4 files changed, 58 insertions(+), 11 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 3d53ce9fcd7..ffe8616d6a1 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -109,7 +109,12 @@ export class SlidingSyncManager {
             }
             list = updatedList;
         }
-        this.slidingSync.setList(listIndex, list);
+        // if we only have range changes then call a different function so we don't nuke the list from before
+        if (updateArgs.ranges && Object.keys(updateArgs).length === 1) {
+            this.slidingSync.setListRanges(listIndex, updateArgs.ranges);
+        } else {
+            this.slidingSync.setList(listIndex, list);
+        }
 
         return new Promise((resolve, reject) => {
             const resolveOnSubscribed = (state, resp, err) => {
@@ -135,7 +140,12 @@ export class SlidingSyncManager {
 
         return new Promise((resolve, reject) => {
             const resolveOnSubscribed = (state, resp, err) => {
-                if (state === SlidingSyncState.Complete) { // we processed a /sync response
+                if (state === SlidingSyncState.Complete) {
+                    if (visible && !resp.room_subscriptions[roomId]) {
+                        // we want roomId but this /sync response doesn't include it yet.
+                        return;
+                    }
+                    // we processed a /sync response which returned this subscription
                     this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
                     resolve(roomId);
                 }
diff --git a/src/components/structures/RoomView.tsx b/src/components/structures/RoomView.tsx
index e7bb9fc9f1b..687b10aab72 100644
--- a/src/components/structures/RoomView.tsx
+++ b/src/components/structures/RoomView.tsx
@@ -108,7 +108,7 @@ import { DoAfterSyncPreparedPayload } from '../../dispatcher/payloads/DoAfterSyn
 import FileDropTarget from './FileDropTarget';
 import Measured from '../views/elements/Measured';
 import { FocusComposerPayload } from '../../dispatcher/payloads/FocusComposerPayload';
-import { getSlidingSyncManager, SlidingSyncManager } from '../../SlidingSyncManager';
+import { getSlidingSyncManager } from '../../SlidingSyncManager';
 
 const DEBUG = false;
 let debuglog = function(msg: string) {};
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index 101242b2385..51ad269b7bf 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -681,10 +681,13 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
             },
             [DefaultTagID.DM]: {
                 is_dm: true,
+                is_invite: false,
+                is_tombstoned: false,
             },
             [DefaultTagID.Untagged]: {
-                is_invite: false,
                 is_dm: false,
+                is_invite: false,
+                is_tombstoned: false,
             },
         };
         return tagOrder.map((tag, index) => {
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 029c096d66d..8823de9271b 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -58,7 +58,7 @@ import { replaceableComponent } from "../../../utils/replaceableComponent";
 import { KeyBindingAction } from "../../../accessibility/KeyboardShortcuts";
 import { ViewRoomPayload } from "../../../dispatcher/payloads/ViewRoomPayload";
 import SettingsStore from "../../../settings/SettingsStore";
-import { getSlidingSyncManager, SlidingSyncManager } from "../../../SlidingSyncManager";
+import { getSlidingSyncManager } from "../../../SlidingSyncManager";
 import { SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import { MatrixClientPeg } from "../../../MatrixClientPeg";
 
@@ -114,6 +114,7 @@ interface IState {
     height: number;
     rooms: Room[];
     filteredExtraTiles?: ReactComponentElement<typeof ExtraTile>[];
+    slidingSyncJoinedCount?: number;
 }
 
 @replaceableComponent("views.rooms.RoomSublist")
@@ -153,6 +154,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             height: 0, // to be fixed in a moment, we need `rooms` to calculate this.
             // sliding sync mode has no rooms initially as we need to fetch them via a request
             rooms: this.slidingSyncMode ? [] : arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || []),
+            slidingSyncJoinedCount: 0,
         };
         // Why Object.assign() and not this.state.height? Because TypeScript says no.
         this.state = Object.assign(this.state, { height: this.calculateInitialHeight() });
@@ -202,6 +204,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     }
 
     private get numVisibleTiles(): number {
+        if (this.slidingSyncMode) {
+            return this.state.rooms.length;
+        }
         const nVisible = Math.ceil(this.layout.visibleTiles);
         return Math.min(nVisible, this.numTiles);
     }
@@ -272,7 +277,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     }
 
     public async componentDidMount() {
-        await this.slidingSyncInit;
+        if (this.slidingSyncMode) {
+            await this.slidingSyncInit;
+        }
 
         this.dispatcherRef = defaultDispatcher.register(this.onAction);
         RoomListStore.instance.on(LISTS_UPDATE_EVENT, this.onListsUpdated);
@@ -302,20 +309,35 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         if (listIndex !== this.props.slidingSyncIndex) {
             return;
         }
+        console.log(roomIndexToRoomId);
         const orderedRoomIds = Object.keys(roomIndexToRoomId).map((numStr) => {
             return Number(numStr);
         }).sort().map((i) => {
-            return roomIndexToRoomId[i];
+            const rid = roomIndexToRoomId[i];
+            if (!rid) {
+                throw new Error("index " + i + " has no room ID");
+            }
+            return rid;
         });
 
-        console.log("onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:", orderedRoomIds);
+        console.log("onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:", orderedRoomIds.length < 30 ? orderedRoomIds : orderedRoomIds.length);
 
         // now set the rooms
         this.setState({
             rooms: orderedRoomIds.map((roomId) => {
                 return MatrixClientPeg.get().getRoom(roomId);
             }),
+            slidingSyncJoinedCount: joinCount,
         });
+
+        if (this.props.forceExpanded && orderedRoomIds.length < joinCount) {
+            // expand the range for this list as we are forcibly showing everything
+            getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
+                ranges: [
+                    [0, joinCount-1],
+                ],
+            });
+        }
     }
 
     private onListsUpdated = () => {
@@ -418,7 +440,15 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         this.setState({ isResizing: false, height: newHeight });
     };
 
-    private onShowAllClick = () => {
+    private onShowAllClick = async () => {
+        if (this.slidingSyncMode) {
+            await getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
+                ranges: [
+                    [0, this.state.slidingSyncJoinedCount-1],
+                ],
+            });
+            return;
+        }
         // read number of visible tiles before we mutate it
         const numVisibleTiles = this.numVisibleTiles;
         const newHeight = this.layout.tilesToPixelsWithPadding(this.numTiles, this.padding);
@@ -872,12 +902,16 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             // floats above the resize handle, if we have one present. If the user has all
             // tiles visible, it becomes 'show less'.
             let showNButton = null;
+            const hasMoreSlidingSync = (this.slidingSyncMode && this.state.slidingSyncJoinedCount > this.state.rooms.length);
 
-            if (maxTilesPx > this.state.height) {
+            if (maxTilesPx > this.state.height || hasMoreSlidingSync) {
                 // the height of all the tiles is greater than the section height: we need a 'show more' button
                 const nonPaddedHeight = this.state.height - RESIZE_HANDLE_HEIGHT - SHOW_N_BUTTON_HEIGHT;
                 const amountFullyShown = Math.floor(nonPaddedHeight / this.layout.tileHeight);
-                const numMissing = this.numTiles - amountFullyShown;
+                let numMissing = this.numTiles - amountFullyShown;
+                if (this.slidingSyncMode) {
+                    numMissing = this.state.slidingSyncJoinedCount - amountFullyShown;
+                }
                 const label = _t("Show %(count)s more", { count: numMissing });
                 let showMoreText = (
                     <span className='mx_RoomSublist_showNButtonText'>

From 557229246ee7c9291c05451c9b989aef848ee4fa Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 22 Mar 2022 18:11:29 +0000
Subject: [PATCH 09/81] update the UI when the list is updated

---
 src/components/views/rooms/RoomSublist.tsx | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 8823de9271b..0c3b12d6e19 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -309,7 +309,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         if (listIndex !== this.props.slidingSyncIndex) {
             return;
         }
-        console.log(roomIndexToRoomId);
+
         const orderedRoomIds = Object.keys(roomIndexToRoomId).map((numStr) => {
             return Number(numStr);
         }).sort().map((i) => {
@@ -320,7 +320,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             return rid;
         });
 
-        console.log("onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:", orderedRoomIds.length < 30 ? orderedRoomIds : orderedRoomIds.length);
+        console.log("onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:", orderedRoomIds.length < 10 ? orderedRoomIds : orderedRoomIds.length);
 
         // now set the rooms
         this.setState({
@@ -447,7 +447,6 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                     [0, this.state.slidingSyncJoinedCount-1],
                 ],
             });
-            return;
         }
         // read number of visible tiles before we mutate it
         const numVisibleTiles = this.numVisibleTiles;
@@ -986,7 +985,6 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 'mx_RoomSublist_resizerHandles': true,
                 'mx_RoomSublist_resizerHandles_showNButton': !!showNButton,
             });
-
             content = (
                 <React.Fragment>
                     <Resizable

From 12fa287df90930c467bed03395dfc4512377015a Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 25 Mar 2022 12:25:53 +0000
Subject: [PATCH 10/81] bugfix: make sure the list sorts numerically

---
 src/components/views/rooms/RoomSublist.tsx | 14 ++++++++------
 src/stores/room-list/RoomListStore.ts      |  3 +++
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 0c3b12d6e19..c359b13550c 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -310,22 +310,24 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             return;
         }
 
-        const orderedRoomIds = Object.keys(roomIndexToRoomId).map((numStr) => {
+        let orderedRoomIndexes = Object.keys(roomIndexToRoomId).map((numStr) => {
             return Number(numStr);
-        }).sort().map((i) => {
+        }).sort((a,b) => {
+            return a-b;
+        });
+        const orderedRoomIds = orderedRoomIndexes.map((i) => {
             const rid = roomIndexToRoomId[i];
             if (!rid) {
                 throw new Error("index " + i + " has no room ID");
             }
             return rid;
         });
-
         console.log("onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:", orderedRoomIds.length < 10 ? orderedRoomIds : orderedRoomIds.length);
-
         // now set the rooms
         this.setState({
-            rooms: orderedRoomIds.map((roomId) => {
-                return MatrixClientPeg.get().getRoom(roomId);
+            rooms: orderedRoomIds.map((roomId, index) => {
+                const r = MatrixClientPeg.get().getRoom(roomId);
+                return r;
             }),
             slidingSyncJoinedCount: joinCount,
         });
diff --git a/src/stores/room-list/RoomListStore.ts b/src/stores/room-list/RoomListStore.ts
index 57303993fe2..3543bf173fa 100644
--- a/src/stores/room-list/RoomListStore.ts
+++ b/src/stores/room-list/RoomListStore.ts
@@ -202,6 +202,9 @@ export class RoomListStoreClass extends AsyncStoreWithClient<IState> {
         // Everything here requires a MatrixClient or some sort of logical readiness.
         const logicallyReady = this.matrixClient && this.initialListsGenerated;
         if (!logicallyReady) return;
+        if (SettingsStore.getValue("slidingSync")) {
+            return; // we don't need any of this in sliding sync mode.
+        }
 
         if (payload.action === Action.SettingUpdated) {
             const settingUpdatedPayload = payload as SettingUpdatedPayload;

From dbc0d573635af483e5d5ce2eebf0423c37bd48ed Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 29 Mar 2022 19:32:24 +0100
Subject: [PATCH 11/81] Get invites transitioning correctly

---
 src/SlidingSyncManager.ts              | 16 ++++++++--------
 src/components/structures/RoomView.tsx |  1 +
 src/stores/room-list/RoomListStore.ts  |  3 +++
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index ffe8616d6a1..1721ddc8cfa 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -139,19 +139,19 @@ export class SlidingSyncManager {
         this.slidingSync.modifyRoomSubscriptions(subscriptions);
 
         return new Promise((resolve, reject) => {
-            const resolveOnSubscribed = (state, resp, err) => {
-                if (state === SlidingSyncState.Complete) {
-                    if (visible && !resp.room_subscriptions[roomId]) {
-                        // we want roomId but this /sync response doesn't include it yet.
-                        return;
-                    }
+            if (this.client.getRoom(roomId)) {
+                resolve(roomId); // we have data already for this room, show immediately e.g it's in a list
+                return;
+            }
+            const resolveOnSubscribed = (gotRoomId: string) => {
+                if (roomId === gotRoomId) {
                     // we processed a /sync response which returned this subscription
-                    this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
+                    this.slidingSync.off(SlidingSyncEvent.RoomData, resolveOnSubscribed);
                     resolve(roomId);
                 }
             };
             // wait until the next sync before returning as RoomView may need to know the current state
-            this.slidingSync.on(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
+            this.slidingSync.on(SlidingSyncEvent.RoomData, resolveOnSubscribed);
         });
     }
 
diff --git a/src/components/structures/RoomView.tsx b/src/components/structures/RoomView.tsx
index 687b10aab72..150c034c788 100644
--- a/src/components/structures/RoomView.tsx
+++ b/src/components/structures/RoomView.tsx
@@ -394,6 +394,7 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
         }
 
         const roomId = RoomViewStore.getRoomId();
+
         if (initial && SettingsStore.getValue("slidingSync")) {
             // set this room as the room subscription. We need to await for it as this will fetch
             // all room state for this room, which is required before we get the state below.
diff --git a/src/stores/room-list/RoomListStore.ts b/src/stores/room-list/RoomListStore.ts
index 3543bf173fa..eb414d1291c 100644
--- a/src/stores/room-list/RoomListStore.ts
+++ b/src/stores/room-list/RoomListStore.ts
@@ -154,6 +154,9 @@ export class RoomListStoreClass extends AsyncStoreWithClient<IState> {
      */
     private handleRVSUpdate({ trigger = true }) {
         if (!this.matrixClient) return; // We assume there won't be RVS updates without a client
+        if (SettingsStore.getValue("slidingSync")) {
+            return; // we don't need any of this in sliding sync mode.
+        }
 
         const activeRoomId = RoomViewStore.getRoomId();
         if (!activeRoomId && this.algorithm.stickyRoom) {

From 04602c3995aa0f22f9bc25eee82a47b75733ff6f Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 14 Apr 2022 10:34:42 +0100
Subject: [PATCH 12/81] Force enable sliding sync and labs for now

---
 src/IConfigOptions.ts | 1 +
 src/SdkConfig.ts      | 8 +++++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/IConfigOptions.ts b/src/IConfigOptions.ts
index cfaeecb75ea..6e7f5a3249f 100644
--- a/src/IConfigOptions.ts
+++ b/src/IConfigOptions.ts
@@ -161,6 +161,7 @@ export interface IConfigOptions {
         domains?: string[];
     };
 
+    sliding_sync_proxy_url?: string;
     enable_presence_by_hs_url?: Record<string, boolean>; // <HomeserverName, Enabled>
 
     terms_and_conditions_links?: { url: string, text: string }[];
diff --git a/src/SdkConfig.ts b/src/SdkConfig.ts
index b38e2848746..3f9ee3e5d7b 100644
--- a/src/SdkConfig.ts
+++ b/src/SdkConfig.ts
@@ -28,7 +28,8 @@ export const DEFAULTS: IConfigOptions = {
     integrations_rest_url: "https://scalar.vector.im/api",
     bug_report_endpoint_url: null,
     // The location of the sliding sync proxy. If not specified, sliding sync mode cannot be enabled.
-    sliding_sync_proxy_url: null,
+    sliding_sync_proxy_url: "https://slidingsync.lab.element.dev",
+
     // Jitsi conference options
     jitsi: {
         preferred_domain: "meet.element.io",
@@ -89,6 +90,11 @@ export default class SdkConfig {
                 cfg[defaultKeys[i]] = DEFAULTS[defaultKeys[i]];
             }
         }
+        // XXX overrides for testing sliding sync on netlify, do not commit this to main!
+        cfg.show_labs_settings = true;
+        cfg.setting_defaults = Object.assign(cfg.setting_defaults || {}, {
+            slidingSync: true,
+        });
         SdkConfig.setInstance(cfg);
     }
 

From b7697794b373e5809b32768a5bea73affdec84b6 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 14 Apr 2022 11:36:21 +0100
Subject: [PATCH 13/81] Linting

---
 src/SlidingSyncManager.ts                     | 38 ++++++++++---------
 src/components/structures/RoomView.tsx        |  2 +-
 src/components/views/rooms/RoomList.tsx       |  2 +-
 src/components/views/rooms/RoomSublist.tsx    | 30 ++++++++++-----
 .../controllers/SlidingSyncController.ts      |  8 ++--
 5 files changed, 46 insertions(+), 34 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 1721ddc8cfa..dadf59ec0dc 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -14,27 +14,26 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-
 /*
  * Sliding Sync Architecture - MSC https://github.com/matrix-org/matrix-spec-proposals/pull/3575
- * 
+ *
  * This is a holistic summary of the changes made to Element-Web / React SDK / JS SDK to enable sliding sync.
  * This summary will hopefully signpost where developers need to look if they want to make changes to this code.
- * 
+ *
  * At the lowest level, the JS SDK contains an HTTP API wrapper function in client.ts. This is used by
  * a SlidingSync class in JS SDK, which contains code to handle list operations (INSERT/DELETE/SYNC/etc)
  * and contains the main request API bodies, but has no code to control updating JS SDK structures: it just
  * exposes an EventEmitter to listen for updates. When MatrixClient.startClient is called, callers need to
  * provide a SlidingSync instance as this contains the main request API params (timeline limit, required state,
  * how many lists, etc).
- * 
+ *
  * The SlidingSyncSdk INTERNAL class in JS SDK attaches listeners to SlidingSync to update JS SDK Room objects,
  * and it conveniently exposes an identical public API to SyncApi (to allow it to be a drop-in replacement).
- * 
+ *
  * At the highest level, SlidingSyncManager contains mechanisms to tell UI lists which rooms to show,
  * and contains the core request API params used in Element-Web. It does this by listening for events
  * emitted by the SlidingSync class and by modifying the request API params on the SlidingSync class.
- * 
+ *
  *    (entry point)                     (updates JS SDK)
  *  SlidingSyncManager                   SlidingSyncSdk
  *       |                                     |
@@ -45,7 +44,7 @@ limitations under the License.
  *                      list ops)
  */
 
-import { MatrixClient } from 'matrix-js-sdk';
+import { MatrixClient } from 'matrix-js-sdk/src/matrix';
 import { MSC3575List, SlidingSync, SlidingSyncEvent, SlidingSyncState } from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";
 
@@ -57,7 +56,7 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
     timeline_limit: 50,
     required_state: [
         ["*", "*"], // all events
-    ]
+    ],
 };
 
 /**
@@ -70,8 +69,10 @@ export class SlidingSyncManager {
     slidingSync: SlidingSync;
     client: MatrixClient;
 
-    constructor(client: MatrixClient, proxyUrl: string){
-        this.slidingSync = new SlidingSync(proxyUrl, [], DEFAULT_ROOM_SUBSCRIPTION_INFO, client, SLIDING_SYNC_TIMEOUT_MS);
+    constructor(client: MatrixClient, proxyUrl: string) {
+        this.slidingSync = new SlidingSync(
+            proxyUrl, [], DEFAULT_ROOM_SUBSCRIPTION_INFO, client, SLIDING_SYNC_TIMEOUT_MS,
+        );
         this.client = client;
     }
 
@@ -81,12 +82,14 @@ export class SlidingSyncManager {
      * @param updateArgs The fields to update on the list.
      * @returns The complete list request params
      */
-    async ensureListRegistered(listIndex: number, updateArgs: { filters?: object, sort?: string[], ranges?: number[][] }): Promise<MSC3575List> {
+    async ensureListRegistered(
+        listIndex: number, updateArgs: { filters?: object, sort?: string[], ranges?: number[][] },
+    ): Promise<MSC3575List> {
         console.log("ensureListRegistered", listIndex, updateArgs);
         let list = this.slidingSync.getList(listIndex);
         if (!list) {
             list = {
-                ranges: [ [0, 20] ],
+                ranges: [[0, 20]],
                 sort: [
                     "by_highlight_count", "by_notification_count", "by_recency",
                 ],
@@ -98,7 +101,7 @@ export class SlidingSyncManager {
                     ["m.room.encryption", ""], // lets rooms be configured for E2EE correctly
                     ["m.room.create", ""], // for isSpaceRoom checks
                     ["m.room.member", this.client.getUserId()], // lets the client calculate that we are in fact in the room
-                ]
+                ],
             };
             list = Object.assign(list, updateArgs);
         } else {
@@ -129,13 +132,13 @@ export class SlidingSyncManager {
     }
 
     setRoomVisible(roomId: string, visible: boolean): Promise<string> {
-        let subscriptions = this.slidingSync.getRoomSubscriptions();
+        const subscriptions = this.slidingSync.getRoomSubscriptions();
         if (visible) {
             subscriptions.add(roomId);
         } else {
             subscriptions.delete(roomId);
         }
-        logger.log("SlidingSync setRoomVisible:",roomId, visible);
+        logger.log("SlidingSync setRoomVisible:", roomId, visible);
         this.slidingSync.modifyRoomSubscriptions(subscriptions);
 
         return new Promise((resolve, reject) => {
@@ -154,8 +157,7 @@ export class SlidingSyncManager {
             this.slidingSync.on(SlidingSyncEvent.RoomData, resolveOnSubscribed);
         });
     }
-
-};
+}
 
 let manager = null;
 export function getSlidingSyncManager(): SlidingSyncManager {
@@ -164,4 +166,4 @@ export function getSlidingSyncManager(): SlidingSyncManager {
 export function create(client: MatrixClient, proxyUrl: string): SlidingSync {
     manager = new SlidingSyncManager(client, proxyUrl);
     return manager.slidingSync;
-}
\ No newline at end of file
+}
diff --git a/src/components/structures/RoomView.tsx b/src/components/structures/RoomView.tsx
index ad195eb4fa9..15e3ab871c3 100644
--- a/src/components/structures/RoomView.tsx
+++ b/src/components/structures/RoomView.tsx
@@ -410,7 +410,7 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
         if (initial && SettingsStore.getValue("slidingSync")) {
             // set this room as the room subscription. We need to await for it as this will fetch
             // all room state for this room, which is required before we get the state below.
-           await getSlidingSyncManager().setRoomVisible(roomId, true);
+            await getSlidingSyncManager().setRoomVisible(roomId, true);
         }
 
         const newState: Pick<IRoomState, any> = {
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index d318e03d05e..4dc8c82ace2 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -658,7 +658,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
                 onListCollapse={this.props.onListCollapse}
                 forceExpanded={false}
             />;
-        })
+        });
     }
 
     public focus(): void {
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index c359b13550c..161363f7a39 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -20,6 +20,7 @@ import * as React from "react";
 import { ComponentType, createRef, ReactComponentElement } from "react";
 import { normalize } from "matrix-js-sdk/src/utils";
 import { Room } from "matrix-js-sdk/src/models/room";
+import { SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import classNames from 'classnames';
 import { Enable, Resizable } from "re-resizable";
 import { Direction } from "re-resizable/lib/resizer";
@@ -59,7 +60,6 @@ import { KeyBindingAction } from "../../../accessibility/KeyboardShortcuts";
 import { ViewRoomPayload } from "../../../dispatcher/payloads/ViewRoomPayload";
 import SettingsStore from "../../../settings/SettingsStore";
 import { getSlidingSyncManager } from "../../../SlidingSyncManager";
-import { SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import { MatrixClientPeg } from "../../../MatrixClientPeg";
 
 const SHOW_N_BUTTON_HEIGHT = 28; // As defined by CSS
@@ -153,7 +153,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             isExpanded: this.isBeingFiltered ? this.isBeingFiltered : !this.layout.isCollapsed,
             height: 0, // to be fixed in a moment, we need `rooms` to calculate this.
             // sliding sync mode has no rooms initially as we need to fetch them via a request
-            rooms: this.slidingSyncMode ? [] : arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || []),
+            rooms: (
+                this.slidingSyncMode ? [] : arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || [])
+            ),
             slidingSyncJoinedCount: 0,
         };
         // Why Object.assign() and not this.state.height? Because TypeScript says no.
@@ -310,9 +312,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             return;
         }
 
-        let orderedRoomIndexes = Object.keys(roomIndexToRoomId).map((numStr) => {
+        const orderedRoomIndexes = Object.keys(roomIndexToRoomId).map((numStr) => {
             return Number(numStr);
-        }).sort((a,b) => {
+        }).sort((a, b) => {
             return a-b;
         });
         const orderedRoomIds = orderedRoomIndexes.map((i) => {
@@ -322,7 +324,10 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             }
             return rid;
         });
-        console.log("onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:", orderedRoomIds.length < 10 ? orderedRoomIds : orderedRoomIds.length);
+        console.log(
+            "onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:",
+            orderedRoomIds.length < 10 ? orderedRoomIds : orderedRoomIds.length,
+        );
         // now set the rooms
         this.setState({
             rooms: orderedRoomIds.map((roomId, index) => {
@@ -363,7 +368,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 const newFilters = Object.assign({
                     room_name_like: nameCondition.search,
                 }, this.props.slidingSyncFilter);
-                // send the new filters up, but don't await it as we'll get poked via onSlidingSyncListUpdate 
+                // send the new filters up, but don't await it as we'll get poked via onSlidingSyncListUpdate
                 getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
                     filters: newFilters,
                 });
@@ -511,7 +516,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 case SortAlgorithm.Alphabetic:
                     await getSlidingSyncManager().ensureListRegistered(
                         this.props.slidingSyncIndex, {
-                            sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic]
+                            sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic],
                         },
                     );
                     break;
@@ -530,7 +535,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             }
             // no need for forceUpdate here as the /sync response will fire onSlidingSyncListUpdate
             return;
-        } 
+        }
         await RoomListStore.instance.setTagSorting(this.props.tagId, sort);
         this.forceUpdate();
     };
@@ -695,7 +700,10 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             if (this.slidingSyncMode) {
                 const slidingList = getSlidingSyncManager().slidingSync.getList(this.props.slidingSyncIndex);
                 isAlphabetical = slidingList.sort[0] === "by_name";
-                isUnreadFirst = slidingList.sort[0] === "by_highlight_count" || slidingList.sort[0] === "by_unread_count";
+                isUnreadFirst = (
+                    slidingList.sort[0] === "by_highlight_count" ||
+                    slidingList.sort[0] === "by_unread_count"
+                );
             }
 
             // Invites don't get some nonsense options, so only add them if we have to.
@@ -903,7 +911,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             // floats above the resize handle, if we have one present. If the user has all
             // tiles visible, it becomes 'show less'.
             let showNButton = null;
-            const hasMoreSlidingSync = (this.slidingSyncMode && this.state.slidingSyncJoinedCount > this.state.rooms.length);
+            const hasMoreSlidingSync = (
+                this.slidingSyncMode && this.state.slidingSyncJoinedCount > this.state.rooms.length
+            );
 
             if (maxTilesPx > this.state.height || hasMoreSlidingSync) {
                 // the height of all the tiles is greater than the section height: we need a 'show more' button
diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
index 99344d78a6d..4491e16e06c 100644
--- a/src/settings/controllers/SlidingSyncController.ts
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -14,15 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { logger } from "matrix-js-sdk/src/logger";
+
 import SettingController from "./SettingController";
 import PlatformPeg from "../../PlatformPeg";
 import { SettingLevel } from "../SettingLevel";
 import SdkConfig from "../../SdkConfig";
-import { logger } from "matrix-js-sdk/src/logger";
 import SettingsStore from "../SettingsStore";
 
 export default class SlidingSyncController extends SettingController {
-
     public async onChange(level: SettingLevel, roomId: string, newValue: any) {
         if (newValue) {
             // run checks against the "proxy" to make sure it is valid BEFORE we start doing things
@@ -52,7 +52,7 @@ export default class SlidingSyncController extends SettingController {
 /**
  * Check that the proxy url is in fact a sliding sync proxy endpoint and it is up.
  * @param endpoint The proxy endpoint url
- * @param hsUrl The homeserver url of the logged in user. 
+ * @param hsUrl The homeserver url of the logged in user.
  * @returns True if the proxy is valid, else throws.
  */
 function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<boolean> {
@@ -81,4 +81,4 @@ function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<boolean> {
         };
         req.send();
     });
-}
\ No newline at end of file
+}

From 086c678b2aa74c1f15e70c7254dce14c36df23e3 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 26 Apr 2022 16:38:21 +0100
Subject: [PATCH 14/81] Disable spotlight search

---
 src/SdkConfig.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/SdkConfig.ts b/src/SdkConfig.ts
index 3f9ee3e5d7b..7a7c123e816 100644
--- a/src/SdkConfig.ts
+++ b/src/SdkConfig.ts
@@ -94,6 +94,10 @@ export default class SdkConfig {
         cfg.show_labs_settings = true;
         cfg.setting_defaults = Object.assign(cfg.setting_defaults || {}, {
             slidingSync: true,
+            features: {
+                // disable spotlight search as sliding sync searches on the server for room names
+                feature_spotlight: false,
+            },
         });
         SdkConfig.setInstance(cfg);
     }

From bc3d9f6f6b954a333abe7b1a1f37228c92b9dcb2 Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Mon, 30 May 2022 14:08:59 +0100
Subject: [PATCH 15/81] Initial cypress plugins for Sliding Sync Proxy

---
 cypress/plugins/docker/index.ts        | 128 +++++++++++++++++++++++++
 cypress/plugins/index.ts               |   4 +
 cypress/plugins/sliding-sync/index.ts  |  85 ++++++++++++++++
 cypress/plugins/synapsedocker/index.ts |  85 ++++------------
 cypress/plugins/utils/port.ts          |  27 ++++++
 5 files changed, 265 insertions(+), 64 deletions(-)
 create mode 100644 cypress/plugins/docker/index.ts
 create mode 100644 cypress/plugins/sliding-sync/index.ts
 create mode 100644 cypress/plugins/utils/port.ts

diff --git a/cypress/plugins/docker/index.ts b/cypress/plugins/docker/index.ts
new file mode 100644
index 00000000000..87ee9f04194
--- /dev/null
+++ b/cypress/plugins/docker/index.ts
@@ -0,0 +1,128 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/// <reference types="cypress" />
+
+import * as os from "os";
+import * as childProcess from "child_process";
+import * as fse from "fs-extra";
+
+import PluginEvents = Cypress.PluginEvents;
+import PluginConfigOptions = Cypress.PluginConfigOptions;
+
+// A cypress plugins to run docker commands
+
+export function dockerRun(args: {
+    image: string;
+    containerName: string;
+    params?: string[];
+}): Promise<string> {
+    const userInfo = os.userInfo();
+    const params = args.params ?? [];
+
+    return new Promise<string>((resolve, reject) => {
+        childProcess.execFile('docker', [
+            "run",
+            "--name", args.containerName,
+            "-d",
+            ...params,
+            // We run the docker container as our uid:gid otherwise cleaning it up any bind mounts can be difficult
+            "-u", `${userInfo.uid}:${userInfo.gid}`,
+            args.image,
+            "run",
+        ], (err, stdout) => {
+            if (err) reject(err);
+            resolve(stdout.trim());
+        });
+    });
+}
+
+export function dockerExec(args: {
+    containerId: string;
+    params: string[];
+}): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+        childProcess.execFile("docker", [
+            "exec", args.containerId,
+            ...args.params,
+        ], { encoding: 'utf8' }, (err, stdout) => {
+            if (err) reject(err);
+            else resolve();
+        });
+    });
+}
+
+export async function dockerLogs(args: {
+    containerId: string;
+    stdoutFile?: string;
+    stderrFile?: string;
+}): Promise<void> {
+    const stdoutFile = args.stdoutFile ? await fse.open(args.stdoutFile, "w") : "ignore";
+    const stderrFile = args.stderrFile ? await fse.open(args.stderrFile, "w") : "ignore";
+
+    await new Promise<void>((resolve) => {
+        childProcess.spawn("docker", [
+            "logs",
+            args.containerId,
+        ], {
+            stdio: ["ignore", stdoutFile, stderrFile],
+        }).once('close', resolve);
+    });
+
+    if (args.stdoutFile) await fse.close(<number>stdoutFile);
+    if (args.stderrFile) await fse.close(<number>stderrFile);
+}
+
+export function dockerStop(args: {
+    containerId: string;
+}): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+        childProcess.execFile('docker', [
+            "stop",
+            args.containerId,
+        ], err => {
+            if (err) reject(err);
+            resolve();
+        });
+    });
+}
+
+export function dockerRm(args: {
+    containerId: string;
+}): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+        childProcess.execFile('docker', [
+            "rm",
+            args.containerId,
+        ], err => {
+            if (err) reject(err);
+            resolve();
+        });
+    });
+}
+
+/**
+ * @type {Cypress.PluginConfig}
+ */
+export function docker(on: PluginEvents, config: PluginConfigOptions) {
+    on("task", {
+        dockerRun,
+        dockerExec,
+        dockerLogs,
+        dockerStop,
+        dockerRm,
+    });
+}
diff --git a/cypress/plugins/index.ts b/cypress/plugins/index.ts
index eab5441c203..04c44850fa8 100644
--- a/cypress/plugins/index.ts
+++ b/cypress/plugins/index.ts
@@ -20,6 +20,8 @@ import PluginEvents = Cypress.PluginEvents;
 import PluginConfigOptions = Cypress.PluginConfigOptions;
 import { performance } from "./performance";
 import { synapseDocker } from "./synapsedocker";
+import { slidingSyncProxyDocker } from "./sliding-sync";
+import { docker } from "./docker";
 
 /**
  * @type {Cypress.PluginConfig}
@@ -27,4 +29,6 @@ import { synapseDocker } from "./synapsedocker";
 export default function(on: PluginEvents, config: PluginConfigOptions) {
     performance(on, config);
     synapseDocker(on, config);
+    slidingSyncProxyDocker(on, config);
+    docker(on, config);
 }
diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
new file mode 100644
index 00000000000..c51d9209840
--- /dev/null
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -0,0 +1,85 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/// <reference types="cypress" />
+
+import PluginEvents = Cypress.PluginEvents;
+import PluginConfigOptions = Cypress.PluginConfigOptions;
+import { dockerRun, dockerStop } from "../docker";
+import { getFreePort } from "../utils/port";
+import { SynapseInstance } from "../synapsedocker";
+
+// A cypress plugins to add command to start & stop https://github.com/matrix-org/sliding-sync
+
+interface ProxyInstance {
+    containerId: string;
+    postgresId: string;
+    port: number;
+}
+
+const POSTGRES_PASSWORD = "p4S5w0rD";
+
+async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
+    console.log("Starting sliding sync proxy...");
+
+    const postgresId = await dockerRun({
+        image: "postgres",
+        containerName: "react-sdk-cypress-sliding-sync-postgres",
+        params: [
+            "-e", `POSTGRES_PASSWORD=${POSTGRES_PASSWORD}`,
+        ],
+    });
+
+    const port = await getFreePort();
+    const containerId = await dockerRun({
+        image: "ghcr.io/matrix-org/sliding-sync-proxy",
+        containerName: "react-sdk-cypress-sliding-sync-proxy",
+        params: [
+            "--rm",
+            "-p", `${port}:8008/tcp`,
+            "--network", postgresId,
+            "-e", `SYNCV3_SERVER=${synapse.baseUrl}`,
+            "-e", `SYNCV3_DB="user=postgres dbname=postgres password=${POSTGRES_PASSWORD} ` +
+                `host=react-sdk-cypress-sliding-sync-postgres sslmode=disable"`,
+        ],
+    });
+
+    return { containerId, postgresId, port };
+}
+
+async function proxyStop(instance: ProxyInstance): Promise<void> {
+    await dockerStop({
+        containerId: instance.containerId,
+    });
+    await dockerStop({
+        containerId: instance.postgresId,
+    });
+
+    console.log("Stopped sliding sync proxy.");
+    // cypress deliberately fails if you return 'undefined', so
+    // return null to signal all is well, and we've handled the task.
+    return null;
+}
+
+/**
+ * @type {Cypress.PluginConfig}
+ */
+export function slidingSyncProxyDocker(on: PluginEvents, config: PluginConfigOptions) {
+    on("task", {
+        proxyStart,
+        proxyStop,
+    });
+}
diff --git a/cypress/plugins/synapsedocker/index.ts b/cypress/plugins/synapsedocker/index.ts
index 7108ade904a..d4b34cf9122 100644
--- a/cypress/plugins/synapsedocker/index.ts
+++ b/cypress/plugins/synapsedocker/index.ts
@@ -19,12 +19,12 @@ limitations under the License.
 import * as path from "path";
 import * as os from "os";
 import * as crypto from "crypto";
-import * as childProcess from "child_process";
 import * as fse from "fs-extra";
-import * as net from "net";
 
 import PluginEvents = Cypress.PluginEvents;
 import PluginConfigOptions = Cypress.PluginConfigOptions;
+import { getFreePort } from "../utils/port";
+import { dockerExec, dockerLogs, dockerRm, dockerRun, dockerStop } from "../docker";
 
 // A cypress plugins to add command to start & stop synapses in
 // docker with preset templates.
@@ -47,16 +47,6 @@ function randB64Bytes(numBytes: number): string {
     return crypto.randomBytes(numBytes).toString("base64").replace(/=*$/, "");
 }
 
-async function getFreePort(): Promise<number> {
-    return new Promise<number>(resolve => {
-        const srv = net.createServer();
-        srv.listen(0, () => {
-            const port = (<net.AddressInfo>srv.address()).port;
-            srv.close(() => resolve(port));
-        });
-    });
-}
-
 async function cfgDirFromTemplate(template: string): Promise<SynapseConfig> {
     const templateDir = path.join(__dirname, "templates", template);
 
@@ -109,32 +99,21 @@ async function synapseStart(template: string): Promise<SynapseInstance> {
 
     console.log(`Starting synapse with config dir ${synCfg.configDir}...`);
 
-    const containerName = `react-sdk-cypress-synapse-${crypto.randomBytes(4).toString("hex")}`;
-    const userInfo = os.userInfo();
-
-    const synapseId = await new Promise<string>((resolve, reject) => {
-        childProcess.execFile('docker', [
-            "run",
-            "--name", containerName,
-            "-d",
+    const synapseId = await dockerRun({
+        image: "matrixdotorg/synapse:develop",
+        containerName: `react-sdk-cypress-sliding-${crypto.randomBytes(4).toString("hex")}`,
+        params: [
             "-v", `${synCfg.configDir}:/data`,
             "-p", `${synCfg.port}:8008/tcp`,
-            // We run the docker container as our uid:gid otherwise cleaning it up its media_store can be difficult
-            "-u", `${userInfo.uid}:${userInfo.gid}`,
-            "matrixdotorg/synapse:develop",
-            "run",
-        ], (err, stdout) => {
-            if (err) reject(err);
-            resolve(stdout.trim());
-        });
+        ],
     });
 
     console.log(`Started synapse with id ${synapseId} on port ${synCfg.port}.`);
 
     // Await Synapse healthcheck
-    await new Promise<void>((resolve, reject) => {
-        childProcess.execFile("docker", [
-            "exec", synapseId,
+    await dockerExec({
+        containerId: synapseId,
+        params: [
             "curl",
             "--connect-timeout", "30",
             "--retry", "30",
@@ -142,10 +121,7 @@ async function synapseStart(template: string): Promise<SynapseInstance> {
             "--retry-all-errors",
             "--silent",
             "http://localhost:8008/health",
-        ], { encoding: 'utf8' }, (err, stdout) => {
-            if (err) reject(err);
-            else resolve();
-        });
+        ],
     });
 
     const synapse: SynapseInstance = { synapseId, ...synCfg };
@@ -162,37 +138,18 @@ async function synapseStop(id: string): Promise<void> {
         const synapseLogsPath = path.join("cypress", "synapselogs", id);
         await fse.ensureDir(synapseLogsPath);
 
-        const stdoutFile = await fse.open(path.join(synapseLogsPath, "stdout.log"), "w");
-        const stderrFile = await fse.open(path.join(synapseLogsPath, "stderr.log"), "w");
-        await new Promise<void>((resolve, reject) => {
-            childProcess.spawn('docker', [
-                "logs",
-                id,
-            ], {
-                stdio: ["ignore", stdoutFile, stderrFile],
-            }).once('close', resolve);
+        await dockerLogs({
+            containerId: id,
+            stdoutFile: path.join(synapseLogsPath, "stdout.log"),
+            stderrFile: path.join(synapseLogsPath, "stderr.log"),
         });
-        await fse.close(stdoutFile);
-        await fse.close(stderrFile);
-
-        await new Promise<void>((resolve, reject) => {
-            childProcess.execFile('docker', [
-                "stop",
-                id,
-            ], err => {
-                if (err) reject(err);
-                resolve();
-            });
+
+        await dockerStop({
+            containerId: id,
         });
     } finally {
-        await new Promise<void>((resolve, reject) => {
-            childProcess.execFile('docker', [
-                "rm",
-                id,
-            ], err => {
-                if (err) reject(err);
-                resolve();
-            });
+        await dockerRm({
+            containerId: id,
         });
     }
 
@@ -202,7 +159,7 @@ async function synapseStop(id: string): Promise<void> {
 
     console.log(`Stopped synapse id ${id}.`);
     // cypress deliberately fails if you return 'undefined', so
-    // return null to signal all is well and we've handled the task.
+    // return null to signal all is well, and we've handled the task.
     return null;
 }
 
diff --git a/cypress/plugins/utils/port.ts b/cypress/plugins/utils/port.ts
new file mode 100644
index 00000000000..064ccc7cf94
--- /dev/null
+++ b/cypress/plugins/utils/port.ts
@@ -0,0 +1,27 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import * as net from "net";
+
+export async function getFreePort(): Promise<number> {
+    return new Promise<number>(resolve => {
+        const srv = net.createServer();
+        srv.listen(0, () => {
+            const port = (<net.AddressInfo>srv.address()).port;
+            srv.close(() => resolve(port));
+        });
+    });
+}

From 56598cbd05f4a3c34fb4df78b494dcfc124032aa Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Mon, 30 May 2022 14:21:57 +0100
Subject: [PATCH 16/81] Use --rm when running Synapse in Docker for Cypress
 tests

---
 cypress/plugins/synapsedocker/index.ts | 33 +++++++++++---------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/cypress/plugins/synapsedocker/index.ts b/cypress/plugins/synapsedocker/index.ts
index d4b34cf9122..e34f01fafbe 100644
--- a/cypress/plugins/synapsedocker/index.ts
+++ b/cypress/plugins/synapsedocker/index.ts
@@ -24,7 +24,7 @@ import * as fse from "fs-extra";
 import PluginEvents = Cypress.PluginEvents;
 import PluginConfigOptions = Cypress.PluginConfigOptions;
 import { getFreePort } from "../utils/port";
-import { dockerExec, dockerLogs, dockerRm, dockerRun, dockerStop } from "../docker";
+import { dockerExec, dockerLogs, dockerRun, dockerStop } from "../docker";
 
 // A cypress plugins to add command to start & stop synapses in
 // docker with preset templates.
@@ -103,6 +103,7 @@ async function synapseStart(template: string): Promise<SynapseInstance> {
         image: "matrixdotorg/synapse:develop",
         containerName: `react-sdk-cypress-sliding-${crypto.randomBytes(4).toString("hex")}`,
         params: [
+            "--rm",
             "-v", `${synCfg.configDir}:/data`,
             "-p", `${synCfg.port}:8008/tcp`,
         ],
@@ -134,24 +135,18 @@ async function synapseStop(id: string): Promise<void> {
 
     if (!synCfg) throw new Error("Unknown synapse ID");
 
-    try {
-        const synapseLogsPath = path.join("cypress", "synapselogs", id);
-        await fse.ensureDir(synapseLogsPath);
-
-        await dockerLogs({
-            containerId: id,
-            stdoutFile: path.join(synapseLogsPath, "stdout.log"),
-            stderrFile: path.join(synapseLogsPath, "stderr.log"),
-        });
-
-        await dockerStop({
-            containerId: id,
-        });
-    } finally {
-        await dockerRm({
-            containerId: id,
-        });
-    }
+    const synapseLogsPath = path.join("cypress", "synapselogs", id);
+    await fse.ensureDir(synapseLogsPath);
+
+    await dockerLogs({
+        containerId: id,
+        stdoutFile: path.join(synapseLogsPath, "stdout.log"),
+        stderrFile: path.join(synapseLogsPath, "stderr.log"),
+    });
+
+    await dockerStop({
+        containerId: id,
+    });
 
     await fse.remove(synCfg.configDir);
 

From 71eb8ad0f7eea06b390235884a2e7a776b36bc7b Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Wed, 15 Jun 2022 11:27:56 +0100
Subject: [PATCH 17/81] Update src/MatrixClientPeg.ts

Co-authored-by: Travis Ralston <travisr@matrix.org>
---
 src/MatrixClientPeg.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/MatrixClientPeg.ts b/src/MatrixClientPeg.ts
index 49fcadd2137..816d09dda6c 100644
--- a/src/MatrixClientPeg.ts
+++ b/src/MatrixClientPeg.ts
@@ -223,7 +223,7 @@ class MatrixClientPegClass implements IMatrixClientPeg {
         opts.clientWellKnownPollPeriod = 2 * 60 * 60; // 2 hours
         opts.experimentalThreadSupport = SettingsStore.getValue("feature_thread");
 
-        if (SettingsStore.getValue("slidingSync") && SdkConfig.get().sliding_sync_proxy_url) {
+        if (SdkConfig.get().sliding_sync_proxy_url && SettingsStore.getValue("slidingSync")) {
             logger.log("Activating sliding sync using proxy at ", SdkConfig.get().sliding_sync_proxy_url);
             opts.slidingSync = SlidingSyncManager.create(
                 this.matrixClient, SdkConfig.get().sliding_sync_proxy_url,

From e393185f0f227a67031a1b077fd2a14294c097ca Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Wed, 15 Jun 2022 11:28:17 +0100
Subject: [PATCH 18/81] Update src/components/views/rooms/RoomSublist.tsx

Co-authored-by: Travis Ralston <travisr@matrix.org>
---
 src/components/views/rooms/RoomSublist.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 016714feac6..78eaa6966b0 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -912,7 +912,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 this.slidingSyncMode && this.state.slidingSyncJoinedCount > this.state.rooms.length
             );
 
-            if (maxTilesPx > this.state.height || hasMoreSlidingSync) {
+            if ((maxTilesPx > this.state.height) || hasMoreSlidingSync) {
                 // the height of all the tiles is greater than the section height: we need a 'show more' button
                 const nonPaddedHeight = this.state.height - RESIZE_HANDLE_HEIGHT - SHOW_N_BUTTON_HEIGHT;
                 const amountFullyShown = Math.floor(nonPaddedHeight / this.layout.tileHeight);

From aa26456c8917c1eedab7b65d862637b5cd85bf1e Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Wed, 15 Jun 2022 11:29:02 +0100
Subject: [PATCH 19/81] Update
 src/settings/controllers/SlidingSyncController.ts

Co-authored-by: Travis Ralston <travisr@matrix.org>
---
 src/settings/controllers/SlidingSyncController.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
index 4491e16e06c..2d8b90f71e7 100644
--- a/src/settings/controllers/SlidingSyncController.ts
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -1,5 +1,5 @@
 /*
-Copyright 2019, 2020 The Matrix.org Foundation C.I.C.
+Copyright 2022 The Matrix.org Foundation C.I.C.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

From 861359110c3ac3e9d77fda124f5b4898e5945565 Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Wed, 15 Jun 2022 11:29:35 +0100
Subject: [PATCH 20/81] Update src/components/views/rooms/RoomSublist.tsx

Co-authored-by: Travis Ralston <travisr@matrix.org>
---
 src/components/views/rooms/RoomSublist.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 78eaa6966b0..e3816a7c371 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -909,7 +909,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             // tiles visible, it becomes 'show less'.
             let showNButton = null;
             const hasMoreSlidingSync = (
-                this.slidingSyncMode && this.state.slidingSyncJoinedCount > this.state.rooms.length
+                this.slidingSyncMode && (this.state.slidingSyncJoinedCount > this.state.rooms.length)
             );
 
             if ((maxTilesPx > this.state.height) || hasMoreSlidingSync) {

From 9e8a80a587f30ecff2619ba33607c7aaacf4b600 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 12 Jul 2022 12:46:10 +0100
Subject: [PATCH 21/81] WIP add room searching to spotlight search

---
 src/SlidingSyncManager.ts                     | 23 ++++-
 .../dialogs/spotlight/SpotlightDialog.tsx     | 67 ++++++++++-----
 src/components/views/rooms/RoomSublist.tsx    |  1 -
 src/hooks/useSlidingSyncRoomSearch.ts         | 86 +++++++++++++++++++
 4 files changed, 150 insertions(+), 27 deletions(-)
 create mode 100644 src/hooks/useSlidingSyncRoomSearch.ts

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index dadf59ec0dc..51725887aa7 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -45,7 +45,10 @@ limitations under the License.
  */
 
 import { MatrixClient } from 'matrix-js-sdk/src/matrix';
-import { MSC3575List, SlidingSync, SlidingSyncEvent, SlidingSyncState } from 'matrix-js-sdk/src/sliding-sync';
+import {
+    MSC3575List, MSC3575SlidingSyncResponse, SlidingSync,
+    SlidingSyncEvent, SlidingSyncState,
+} from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";
 
 // how long to long poll for
@@ -68,6 +71,7 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
 export class SlidingSyncManager {
     slidingSync: SlidingSync;
     client: MatrixClient;
+    searchListIndex: number;
 
     constructor(client: MatrixClient, proxyUrl: string) {
         this.slidingSync = new SlidingSync(
@@ -76,6 +80,18 @@ export class SlidingSyncManager {
         this.client = client;
     }
 
+    /**
+     * Allocate and return a list index for searching rooms. This ensures that 1 list only is allocated
+     * for searching rooms in sliding sync. This must be called after room list indexes have been allocated.
+     * @returns The list index for searching rooms
+     */
+    getSearchListIndex(): number {
+        if (!this.searchListIndex) {
+            this.searchListIndex = this.slidingSync.listLength();
+        }
+        return this.searchListIndex;
+    }
+
     /**
      * Ensure that this list is registered.
      * @param listIndex The list index to register
@@ -120,8 +136,9 @@ export class SlidingSyncManager {
         }
 
         return new Promise((resolve, reject) => {
-            const resolveOnSubscribed = (state, resp, err) => {
-                if (state === SlidingSyncState.Complete) { // we processed a /sync response
+            const resolveOnSubscribed = (state: SlidingSyncState, resp: MSC3575SlidingSyncResponse, err: Error) => {
+                if (state === SlidingSyncState.Complete && resp.lists[listIndex]) { // we processed a /sync response
+                    console.log("resolving promise, data ", resp);
                     this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
                     resolve(list);
                 }
diff --git a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
index d18d99c66c8..adcd179e8b3 100644
--- a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
+++ b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
@@ -90,6 +90,7 @@ import { Option } from "./Option";
 import { PublicRoomResultDetails } from "./PublicRoomResultDetails";
 import { RoomContextDetails } from "../../rooms/RoomContextDetails";
 import { TooltipOption } from "./TooltipOption";
+import { useSlidingSyncRoomSearch } from "../../../../hooks/useSlidingSyncRoomSearch";
 
 const MAX_RECENT_SEARCHES = 10;
 const SECTION_LIMIT = 50; // only show 50 results per section for performance reasons
@@ -335,25 +336,42 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
         searchProfileInfo,
         searchParams,
     );
+    const isSlidingSyncEnabled = SettingsStore.getValue("slidingSync");
+    let {
+        loading: slidingSyncRoomSearchLoading,
+        rooms: slidingSyncRooms,
+        search: searchRoomsServerside,
+    } = useSlidingSyncRoomSearch();
+    useDebouncedCallback(isSlidingSyncEnabled, searchRoomsServerside, searchParams);
+    if (!isSlidingSyncEnabled) {
+        slidingSyncRoomSearchLoading = false;
+    }
+
     const possibleResults = useMemo<Result[]>(
         () => {
-            const roomResults = findVisibleRooms(cli).map(toRoomResult);
-            // If we already have a DM with the user we're looking for, we will
-            // show that DM instead of the user themselves
-            const alreadyAddedUserIds = roomResults.reduce((userIds, result) => {
-                const userId = DMRoomMap.shared().getUserIdForRoomId(result.room.roomId);
-                if (!userId) return userIds;
-                if (result.room.getJoinedMemberCount() > 2) return userIds;
-                userIds.add(userId);
-                return userIds;
-            }, new Set<string>());
             const userResults = [];
-            for (const user of [...findVisibleRoomMembers(cli), ...users]) {
-                // Make sure we don't have any user more than once
-                if (alreadyAddedUserIds.has(user.userId)) continue;
-                alreadyAddedUserIds.add(user.userId);
-
-                userResults.push(toMemberResult(user));
+            let roomResults;
+            if (isSlidingSyncEnabled) {
+                // use the rooms sliding sync returned as the server has already worked it out for us
+                roomResults = slidingSyncRooms.map(toRoomResult);
+            } else {
+                roomResults = findVisibleRooms(cli).map(toRoomResult);
+                // If we already have a DM with the user we're looking for, we will
+                // show that DM instead of the user themselves
+                const alreadyAddedUserIds = roomResults.reduce((userIds, result) => {
+                    const userId = DMRoomMap.shared().getUserIdForRoomId(result.room.roomId);
+                    if (!userId) return userIds;
+                    if (result.room.getJoinedMemberCount() > 2) return userIds;
+                    userIds.add(userId);
+                    return userIds;
+                }, new Set<string>());
+                for (const user of [...findVisibleRoomMembers(cli), ...users]) {
+                    // Make sure we don't have any user more than once
+                    if (alreadyAddedUserIds.has(user.userId)) continue;
+                    alreadyAddedUserIds.add(user.userId);
+
+                    userResults.push(toMemberResult(user));
+                }
             }
 
             return [
@@ -375,7 +393,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
                 ...publicRooms.map(toPublicRoomResult),
             ].filter(result => filter === null || result.filter.includes(filter));
         },
-        [cli, users, profile, publicRooms, filter],
+        [cli, users, profile, publicRooms, slidingSyncRooms, isSlidingSyncEnabled, filter],
     );
 
     const results = useMemo<Record<Section, Result[]>>(() => {
@@ -394,10 +412,13 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
 
             possibleResults.forEach(entry => {
                 if (isRoomResult(entry)) {
-                    if (!entry.room.normalizedName.includes(normalizedQuery) &&
-                        !entry.room.getCanonicalAlias()?.toLowerCase().includes(lcQuery) &&
-                        !entry.query?.some(q => q.includes(lcQuery))
-                    ) return; // bail, does not match query
+                    // sliding sync gives the correct rooms in the list so we don't need to filter
+                    if (!isSlidingSyncEnabled) {
+                        if (!entry.room.normalizedName.includes(normalizedQuery) &&
+                            !entry.room.getCanonicalAlias()?.toLowerCase().includes(lcQuery) &&
+                            !entry.query?.some(q => q.includes(lcQuery))
+                        ) return; // bail, does not match query
+                    }
                 } else if (isMemberResult(entry)) {
                     if (!entry.query?.some(q => q.includes(lcQuery))) return; // bail, does not match query
                 } else if (isPublicRoomResult(entry)) {
@@ -448,7 +469,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
         }
 
         return results;
-    }, [trimmedQuery, filter, cli, possibleResults, memberComparator]);
+    }, [trimmedQuery, filter, cli, possibleResults, isSlidingSyncEnabled, memberComparator]);
 
     const numResults = sum(Object.values(results).map(it => it.length));
     useWebSearchMetrics(numResults, query.length, true);
@@ -1172,7 +1193,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
                     aria-label={_t("Search")}
                     aria-describedby="mx_SpotlightDialog_keyboardPrompt"
                 />
-                { (publicRoomsLoading || peopleLoading || profileLoading) && (
+                { (publicRoomsLoading || peopleLoading || profileLoading || slidingSyncRoomSearchLoading) && (
                     <Spinner w={24} h={24} />
                 ) }
             </div>
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 62a0eed2a00..92c8f56c617 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -16,7 +16,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { normalize } from "matrix-js-sdk/src/utils";
 import { Room } from "matrix-js-sdk/src/models/room";
 import { SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import classNames from 'classnames';
diff --git a/src/hooks/useSlidingSyncRoomSearch.ts b/src/hooks/useSlidingSyncRoomSearch.ts
new file mode 100644
index 00000000000..8de8b9bf5e6
--- /dev/null
+++ b/src/hooks/useSlidingSyncRoomSearch.ts
@@ -0,0 +1,86 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { useCallback, useState } from "react";
+import { Room } from "matrix-js-sdk/src/models/room";
+
+import { MatrixClientPeg } from "../MatrixClientPeg";
+import { useLatestResult } from "./useLatestResult";
+import { getSlidingSyncManager } from "../SlidingSyncManager";
+
+export interface ISlidingSyncRoomSearchOpts {
+    limit: number;
+    query?: string;
+}
+
+export const useSlidingSyncRoomSearch = () => {
+    const [rooms, setRooms] = useState<Room[]>([]);
+
+    const [loading, setLoading] = useState(false);
+    const listIndex = getSlidingSyncManager().getSearchListIndex();
+
+    const [updateQuery, updateResult] = useLatestResult<{ term: string, limit?: number }, Room[]>(setRooms);
+
+    const search = useCallback(async ({
+        limit = 100,
+        query: term,
+    }: ISlidingSyncRoomSearchOpts): Promise<boolean> => {
+        const opts = { limit, term };
+        updateQuery(opts);
+
+        if (!term?.length) {
+            setRooms([]);
+            return true;
+        }
+
+        try {
+            setLoading(true);
+            await getSlidingSyncManager().ensureListRegistered(listIndex, {
+                ranges: [[0, limit]],
+                filters: {
+                    room_name_like: term,
+                },
+            });
+            const rooms = [];
+            const { roomIndexToRoomId } = getSlidingSyncManager().slidingSync.getListData(listIndex);
+            let i = 0;
+            while (roomIndexToRoomId[i]) {
+                const roomId = roomIndexToRoomId[i];
+                const room = MatrixClientPeg.get().getRoom(roomId);
+                if (room) {
+                    rooms.push(room);
+                }
+                i++;
+            }
+            updateResult(opts, rooms);
+            return true;
+        } catch (e) {
+            console.error("Could not fetch sliding sync rooms for params", { limit, term }, e);
+            updateResult(opts, []);
+            return false;
+        } finally {
+            setLoading(false);
+            // TODO: delete the list?
+        }
+    }, [updateQuery, updateResult, listIndex]);
+
+    return {
+        ready: true,
+        loading,
+        rooms,
+        search,
+    } as const;
+};

From a03c1724bb7e4029758621f3fc7d92e73a321bb0 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 14 Jul 2022 09:12:49 +0100
Subject: [PATCH 22/81] Only read sliding sync results when there is a result,
 else use the local cache

---
 src/components/views/dialogs/spotlight/SpotlightDialog.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
index adcd179e8b3..0e02ac64f09 100644
--- a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
+++ b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
@@ -351,7 +351,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
         () => {
             const userResults = [];
             let roomResults;
-            if (isSlidingSyncEnabled) {
+            if (isSlidingSyncEnabled && slidingSyncRooms.length > 0) {
                 // use the rooms sliding sync returned as the server has already worked it out for us
                 roomResults = slidingSyncRooms.map(toRoomResult);
             } else {

From fb1e9c07649ca3b25a8dd40314618ab0ce1cbd76 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 14 Jul 2022 14:37:16 +0100
Subject: [PATCH 23/81] Use feature_sliding_sync not slidingSync

---
 src/MatrixClientPeg.ts                             |  2 +-
 src/SdkConfig.ts                                   |  7 -------
 src/SlidingSyncManager.ts                          |  1 -
 src/components/structures/RoomView.tsx             |  4 ++--
 .../views/dialogs/spotlight/SpotlightDialog.tsx    |  2 +-
 src/components/views/rooms/RoomList.tsx            |  2 +-
 src/components/views/rooms/RoomSublist.tsx         |  2 +-
 .../settings/tabs/user/LabsUserSettingsTab.tsx     |  8 --------
 src/i18n/strings/en_EN.json                        |  2 +-
 src/rageshake/submit-rageshake.ts                  |  5 +++--
 src/sentry.ts                                      |  2 --
 src/settings/Settings.tsx                          | 14 ++++++++------
 src/settings/controllers/SlidingSyncController.ts  |  2 +-
 src/stores/room-list/RoomListStore.ts              |  4 ++--
 14 files changed, 21 insertions(+), 36 deletions(-)

diff --git a/src/MatrixClientPeg.ts b/src/MatrixClientPeg.ts
index 816d09dda6c..229d789b81a 100644
--- a/src/MatrixClientPeg.ts
+++ b/src/MatrixClientPeg.ts
@@ -223,7 +223,7 @@ class MatrixClientPegClass implements IMatrixClientPeg {
         opts.clientWellKnownPollPeriod = 2 * 60 * 60; // 2 hours
         opts.experimentalThreadSupport = SettingsStore.getValue("feature_thread");
 
-        if (SdkConfig.get().sliding_sync_proxy_url && SettingsStore.getValue("slidingSync")) {
+        if (SdkConfig.get().sliding_sync_proxy_url && SettingsStore.getValue("feature_sliding_sync")) {
             logger.log("Activating sliding sync using proxy at ", SdkConfig.get().sliding_sync_proxy_url);
             opts.slidingSync = SlidingSyncManager.create(
                 this.matrixClient, SdkConfig.get().sliding_sync_proxy_url,
diff --git a/src/SdkConfig.ts b/src/SdkConfig.ts
index 7a7c123e816..3ada8323c38 100644
--- a/src/SdkConfig.ts
+++ b/src/SdkConfig.ts
@@ -92,13 +92,6 @@ export default class SdkConfig {
         }
         // XXX overrides for testing sliding sync on netlify, do not commit this to main!
         cfg.show_labs_settings = true;
-        cfg.setting_defaults = Object.assign(cfg.setting_defaults || {}, {
-            slidingSync: true,
-            features: {
-                // disable spotlight search as sliding sync searches on the server for room names
-                feature_spotlight: false,
-            },
-        });
         SdkConfig.setInstance(cfg);
     }
 
diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 51725887aa7..cf7b511f25c 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -138,7 +138,6 @@ export class SlidingSyncManager {
         return new Promise((resolve, reject) => {
             const resolveOnSubscribed = (state: SlidingSyncState, resp: MSC3575SlidingSyncResponse, err: Error) => {
                 if (state === SlidingSyncState.Complete && resp.lists[listIndex]) { // we processed a /sync response
-                    console.log("resolving promise, data ", resp);
                     this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
                     resolve(list);
                 }
diff --git a/src/components/structures/RoomView.tsx b/src/components/structures/RoomView.tsx
index 1c98a236c13..9f4f312ab23 100644
--- a/src/components/structures/RoomView.tsx
+++ b/src/components/structures/RoomView.tsx
@@ -407,7 +407,7 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
 
         const roomId = RoomViewStore.instance.getRoomId();
 
-        if (initial && SettingsStore.getValue("slidingSync")) {
+        if (initial && SettingsStore.getValue("feature_sliding_sync")) {
             // set this room as the room subscription. We need to await for it as this will fetch
             // all room state for this room, which is required before we get the state below.
             await getSlidingSyncManager().setRoomVisible(roomId, true);
@@ -724,7 +724,7 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
             this.context.stopPeeking();
         }
 
-        if (SettingsStore.getValue("slidingSync")) {
+        if (SettingsStore.getValue("feature_sliding_sync")) {
             // unsubscribe from this room, but don't await it as we don't care when this gets done.
             getSlidingSyncManager().setRoomVisible(this.state.roomId, false);
         }
diff --git a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
index 0e02ac64f09..c1c0d3dd086 100644
--- a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
+++ b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
@@ -336,7 +336,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
         searchProfileInfo,
         searchParams,
     );
-    const isSlidingSyncEnabled = SettingsStore.getValue("slidingSync");
+    const isSlidingSyncEnabled = SettingsStore.getValue("feature_sliding_sync");
     let {
         loading: slidingSyncRoomSearchLoading,
         rooms: slidingSyncRooms,
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index f13efd43f6f..0d6cf859138 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -547,7 +547,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
     }
 
     private renderSublists(): React.ReactElement[] {
-        if (SettingsStore.getValue("slidingSync")) {
+        if (SettingsStore.getValue("feature_sliding_sync")) {
             return this.renderSlidingSyncLists();
         }
         // show a skeleton UI if the user is in no rooms and they are not filtering and have no suggested rooms
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 92c8f56c617..78121d61720 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -129,7 +129,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     constructor(props: IProps) {
         super(props);
         // when this setting is toggled it restarts the app so it's safe to not watch this.
-        this.slidingSyncMode = SettingsStore.getValue("slidingSync");
+        this.slidingSyncMode = SettingsStore.getValue("feature_sliding_sync");
         if (this.slidingSyncMode) {
             this.onSlidingSyncListUpdate = this.onSlidingSyncListUpdate.bind(this);
             this.slidingSyncInit = getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
diff --git a/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx b/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx
index 738fea91bf0..94f65d9de2d 100644
--- a/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx
+++ b/src/components/views/settings/tabs/user/LabsUserSettingsTab.tsx
@@ -108,14 +108,6 @@ export default class LabsUserSettingsTab extends React.Component<{}, IState> {
                 />,
             );
 
-            groups.getOrCreate(LabGroup.Experimental, []).push(
-                <SettingsFlag
-                    key="slidingSync"
-                    name="slidingSync"
-                    level={SettingLevel.DEVICE}
-                />,
-            );
-
             groups.getOrCreate(LabGroup.Analytics, []).push(
                 <SettingsFlag
                     key="automaticErrorReporting"
diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json
index d8b907269c5..fa9ae02663a 100644
--- a/src/i18n/strings/en_EN.json
+++ b/src/i18n/strings/en_EN.json
@@ -951,7 +951,7 @@
     "Show shortcuts to recently viewed rooms above the room list": "Show shortcuts to recently viewed rooms above the room list",
     "Show hidden events in timeline": "Show hidden events in timeline",
     "Low bandwidth mode (requires compatible homeserver)": "Low bandwidth mode (requires compatible homeserver)",
-    "Sliding Sync mode (requires proxy, set via \"sliding_sync_proxy_url\" in config.json)": "Sliding Sync mode (requires proxy, set via \"sliding_sync_proxy_url\" in config.json)",
+    "Sliding Sync mode (under active development)": "Sliding Sync mode (under active development)",
     "Allow fallback call assist server turn.matrix.org when your homeserver does not offer one (your IP address would be shared during a call)": "Allow fallback call assist server turn.matrix.org when your homeserver does not offer one (your IP address would be shared during a call)",
     "Show previews/thumbnails for images": "Show previews/thumbnails for images",
     "Enable message search in encrypted rooms": "Enable message search in encrypted rooms",
diff --git a/src/rageshake/submit-rageshake.ts b/src/rageshake/submit-rageshake.ts
index 53d987a282c..e202f993504 100644
--- a/src/rageshake/submit-rageshake.ts
+++ b/src/rageshake/submit-rageshake.ts
@@ -137,8 +137,9 @@ async function collectBugReport(opts: IOpts = {}, gzipLogs = true) {
         body.append("lowBandwidth", "enabled");
     }
 
-    if (SettingsStore.getValue("slidingSync")) {
-        body.append("slidingSync", "enabled");
+    // if sliding sync mode is enabled, say so over rageshake, since it's a huge change and can cause issues
+    if (SettingsStore.getValue("feature_sliding_sync")) {
+        body.append("feature_sliding_sync", "enabled");
     }
 
     // add storage persistence/quota information
diff --git a/src/sentry.ts b/src/sentry.ts
index 8aa1b4247f2..476da497a7b 100644
--- a/src/sentry.ts
+++ b/src/sentry.ts
@@ -35,7 +35,6 @@ type UserContext = {
     username: string;
     enabled_labs: string;
     low_bandwidth: string;
-    sliding_sync: string;
 };
 
 type CryptoContext = {
@@ -104,7 +103,6 @@ function getUserContext(client: MatrixClient): UserContext {
         "username": client.credentials.userId,
         "enabled_labs": getEnabledLabs(),
         "low_bandwidth": SettingsStore.getValue("lowBandwidth") ? "enabled" : "disabled",
-        "sliding_sync": SettingsStore.getValue("slidingSync") ? "enabled" : "disabled",
     };
 }
 
diff --git a/src/settings/Settings.tsx b/src/settings/Settings.tsx
index 1ea87e5539a..fa5d8599d49 100644
--- a/src/settings/Settings.tsx
+++ b/src/settings/Settings.tsx
@@ -407,6 +407,14 @@ export const SETTINGS: {[setting: string]: ISetting} = {
         displayName: _td("Don't send read receipts"),
         default: false,
     },
+    "feature_sliding_sync": {
+        isFeature: true,
+        labsGroup: LabGroup.Developer,
+        supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
+        displayName: _td('Sliding Sync mode (under active development)'),
+        default: true, // XXX: overrides for testing sliding sync on netlify, do not commit this to main!
+        controller: new SlidingSyncController(),
+    },
     "feature_message_right_click_context_menu": {
         isFeature: true,
         supportedLevels: LEVELS_FEATURE,
@@ -805,12 +813,6 @@ export const SETTINGS: {[setting: string]: ISetting} = {
         default: false,
         controller: new ReloadOnChangeController(),
     },
-    "slidingSync": {
-        supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
-        displayName: _td('Sliding Sync mode (requires proxy, set via "sliding_sync_proxy_url" in config.json)'),
-        default: false,
-        controller: new SlidingSyncController(),
-    },
     "fallbackICEServerAllowed": {
         supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS,
         displayName: _td(
diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
index 2d8b90f71e7..b874430d06a 100644
--- a/src/settings/controllers/SlidingSyncController.ts
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -37,7 +37,7 @@ export default class SlidingSyncController extends SettingController {
                 console.error(err);
                 // force the value to false, this is a bit ew, it would be nice if we could return
                 // a bool as to whether to go through with the change or not.
-                SettingsStore.setValue("slidingSync", roomId, level, false);
+                SettingsStore.setValue("feature_sliding_sync", roomId, level, false);
                 return;
             }
         }
diff --git a/src/stores/room-list/RoomListStore.ts b/src/stores/room-list/RoomListStore.ts
index 5058dd8cbd3..c2cf495acbd 100644
--- a/src/stores/room-list/RoomListStore.ts
+++ b/src/stores/room-list/RoomListStore.ts
@@ -127,7 +127,7 @@ export class RoomListStoreClass extends AsyncStoreWithClient<IState> {
      */
     private handleRVSUpdate({ trigger = true }) {
         if (!this.matrixClient) return; // We assume there won't be RVS updates without a client
-        if (SettingsStore.getValue("slidingSync")) {
+        if (SettingsStore.getValue("feature_sliding_sync")) {
             return; // we don't need any of this in sliding sync mode.
         }
 
@@ -178,7 +178,7 @@ export class RoomListStoreClass extends AsyncStoreWithClient<IState> {
         // Everything here requires a MatrixClient or some sort of logical readiness.
         const logicallyReady = this.matrixClient && this.initialListsGenerated;
         if (!logicallyReady) return;
-        if (SettingsStore.getValue("slidingSync")) {
+        if (SettingsStore.getValue("feature_sliding_sync")) {
             return; // we don't need any of this in sliding sync mode.
         }
 

From 4143d13c39e95c75846449ffc7c0683c65069277 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 14 Jul 2022 17:52:46 +0100
Subject: [PATCH 24/81] Some review comments

---
 src/SlidingSyncManager.ts                  | 8 ++++----
 src/components/views/rooms/RoomSublist.tsx | 8 +++++---
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index cf7b511f25c..2dc9377ecd1 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -101,7 +101,7 @@ export class SlidingSyncManager {
     async ensureListRegistered(
         listIndex: number, updateArgs: { filters?: object, sort?: string[], ranges?: number[][] },
     ): Promise<MSC3575List> {
-        console.log("ensureListRegistered", listIndex, updateArgs);
+        logger.debug("ensureListRegistered", listIndex, updateArgs);
         let list = this.slidingSync.getList(listIndex);
         if (!list) {
             list = {
@@ -123,7 +123,7 @@ export class SlidingSyncManager {
         } else {
             const updatedList = Object.assign({}, list, updateArgs);
             if (JSON.stringify(list) === JSON.stringify(updatedList)) {
-                console.log("list matches, not sending, update => ", updateArgs);
+                logger.debug("list matches, not sending, update => ", updateArgs);
                 return list;
             }
             list = updatedList;
@@ -135,7 +135,7 @@ export class SlidingSyncManager {
             this.slidingSync.setList(listIndex, list);
         }
 
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             const resolveOnSubscribed = (state: SlidingSyncState, resp: MSC3575SlidingSyncResponse, err: Error) => {
                 if (state === SlidingSyncState.Complete && resp.lists[listIndex]) { // we processed a /sync response
                     this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
@@ -157,7 +157,7 @@ export class SlidingSyncManager {
         logger.log("SlidingSync setRoomVisible:", roomId, visible);
         this.slidingSync.modifyRoomSubscriptions(subscriptions);
 
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             if (this.client.getRoom(roomId)) {
                 resolve(roomId); // we have data already for this room, show immediately e.g it's in a list
                 return;
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 78121d61720..ce5bd73e372 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -58,6 +58,7 @@ import { getSlidingSyncManager } from "../../../SlidingSyncManager";
 import { MatrixClientPeg } from "../../../MatrixClientPeg";
 import NotificationBadge from "./NotificationBadge";
 import RoomTile from "./RoomTile";
+import { logger } from "matrix-js-sdk/src/logger";
 
 const SHOW_N_BUTTON_HEIGHT = 28; // As defined by CSS
 const RESIZE_HANDLE_HEIGHT = 4; // As defined by CSS
@@ -315,7 +316,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             }
             return rid;
         });
-        console.log(
+        logger.debug(
             "onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:",
             orderedRoomIds.length < 10 ? orderedRoomIds : orderedRoomIds.length,
         );
@@ -484,10 +485,10 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                     );
                     break;
                 case SortAlgorithm.Manual:
-                    console.error("cannot enable manual sort in sliding sync mode");
+                    logger.error("cannot enable manual sort in sliding sync mode");
                     break;
                 default:
-                    console.error("unknown sort mode: ", sort);
+                    logger.error("unknown sort mode: ", sort);
             }
             // no need for forceUpdate here as the /sync response will fire onSlidingSyncListUpdate
             return;
@@ -953,6 +954,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 'mx_RoomSublist_resizerHandles': true,
                 'mx_RoomSublist_resizerHandles_showNButton': !!showNButton,
             });
+
             content = (
                 <React.Fragment>
                     <Resizable

From 79e6ee960d51385a1f06a0da8dd45fe607074b35 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 20 Jul 2022 16:12:23 +0100
Subject: [PATCH 25/81] More review comments

---
 src/MatrixClientPeg.ts                        |  4 +-
 src/SlidingSyncManager.ts                     | 46 +++++++++++--------
 src/components/structures/RoomView.tsx        |  6 +--
 src/components/views/rooms/RoomList.tsx       |  4 +-
 src/components/views/rooms/RoomSublist.tsx    | 24 +++++-----
 src/hooks/useSlidingSyncRoomSearch.ts         |  8 ++--
 .../controllers/SlidingSyncController.ts      | 44 ++++++++----------
 7 files changed, 68 insertions(+), 68 deletions(-)

diff --git a/src/MatrixClientPeg.ts b/src/MatrixClientPeg.ts
index 229d789b81a..9274ec231dc 100644
--- a/src/MatrixClientPeg.ts
+++ b/src/MatrixClientPeg.ts
@@ -37,7 +37,7 @@ import IdentityAuthClient from './IdentityAuthClient';
 import { crossSigningCallbacks, tryToUnlockSecretStorageWithDehydrationKey } from './SecurityManager';
 import SecurityCustomisations from "./customisations/Security";
 import SdkConfig from './SdkConfig';
-import * as SlidingSyncManager from './SlidingSyncManager';
+import { SlidingSyncManager } from './SlidingSyncManager';
 import CryptoStoreTooNewDialog from "./components/views/dialogs/CryptoStoreTooNewDialog";
 
 export interface IMatrixClientCreds {
@@ -225,7 +225,7 @@ class MatrixClientPegClass implements IMatrixClientPeg {
 
         if (SdkConfig.get().sliding_sync_proxy_url && SettingsStore.getValue("feature_sliding_sync")) {
             logger.log("Activating sliding sync using proxy at ", SdkConfig.get().sliding_sync_proxy_url);
-            opts.slidingSync = SlidingSyncManager.create(
+            opts.slidingSync = SlidingSyncManager.instance.configure(
                 this.matrixClient, SdkConfig.get().sliding_sync_proxy_url,
             );
         }
diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 2dc9377ecd1..66dee5abed4 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -45,7 +45,9 @@ limitations under the License.
  */
 
 import { MatrixClient } from 'matrix-js-sdk/src/matrix';
+import { EventType } from 'matrix-js-sdk/src/@types/event';
 import {
+    MSC3575Filter,
     MSC3575List, MSC3575SlidingSyncResponse, SlidingSync,
     SlidingSyncEvent, SlidingSyncState,
 } from 'matrix-js-sdk/src/sliding-sync';
@@ -62,6 +64,8 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
     ],
 };
 
+export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[], ranges?: number[][] };
+
 /**
  * This class manages the entirety of sliding sync at a high UI/UX level. It controls the placement
  * of placeholders in lists, controls updating sliding window ranges, and controls which events
@@ -69,15 +73,25 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
  * sync options and code.
  */
 export class SlidingSyncManager {
-    slidingSync: SlidingSync;
-    client: MatrixClient;
-    searchListIndex: number;
+    private static internalInstance = new SlidingSyncManager();
+
+    public slidingSync: SlidingSync;
+    private client: MatrixClient;
+    private searchListIndex: number;
+
+    constructor(){}
+
+    public static get instance(): SlidingSyncManager {
+        return SlidingSyncManager.internalInstance;
+    }
 
-    constructor(client: MatrixClient, proxyUrl: string) {
+    public configure(client: MatrixClient, proxyUrl: string): SlidingSync {
         this.slidingSync = new SlidingSync(
             proxyUrl, [], DEFAULT_ROOM_SUBSCRIPTION_INFO, client, SLIDING_SYNC_TIMEOUT_MS,
         );
         this.client = client;
+        this.searchListIndex = undefined;
+        return this.slidingSync;
     }
 
     /**
@@ -99,7 +113,7 @@ export class SlidingSyncManager {
      * @returns The complete list request params
      */
     async ensureListRegistered(
-        listIndex: number, updateArgs: { filters?: object, sort?: string[], ranges?: number[][] },
+        listIndex: number, updateArgs: PartialSlidingSyncRequest,
     ): Promise<MSC3575List> {
         logger.debug("ensureListRegistered", listIndex, updateArgs);
         let list = this.slidingSync.getList(listIndex);
@@ -111,17 +125,18 @@ export class SlidingSyncManager {
                 ],
                 timeline_limit: 1, // most recent message display: though this seems to only be needed for favourites?
                 required_state: [
-                    ["m.room.join_rules", ""], // the public icon on the room list
-                    ["m.room.avatar", ""], // any room avatar
-                    ["m.room.tombstone", ""], // lets JS SDK hide rooms which are dead
-                    ["m.room.encryption", ""], // lets rooms be configured for E2EE correctly
-                    ["m.room.create", ""], // for isSpaceRoom checks
-                    ["m.room.member", this.client.getUserId()], // lets the client calculate that we are in fact in the room
+                    [EventType.RoomJoinRules, ""], // the public icon on the room list
+                    [EventType.RoomAvatar, ""], // any room avatar
+                    [EventType.RoomTombstone, ""], // lets JS SDK hide rooms which are dead
+                    [EventType.RoomEncryption, ""], // lets rooms be configured for E2EE correctly
+                    [EventType.RoomCreate, ""], // for isSpaceRoom checks
+                    [EventType.RoomMember, this.client.getUserId()], // lets the client calculate that we are in fact in the room
                 ],
             };
             list = Object.assign(list, updateArgs);
         } else {
             const updatedList = Object.assign({}, list, updateArgs);
+            // cannot use objectHasDiff as we need to do deep diff checking
             if (JSON.stringify(list) === JSON.stringify(updatedList)) {
                 logger.debug("list matches, not sending, update => ", updateArgs);
                 return list;
@@ -174,12 +189,3 @@ export class SlidingSyncManager {
         });
     }
 }
-
-let manager = null;
-export function getSlidingSyncManager(): SlidingSyncManager {
-    return manager;
-}
-export function create(client: MatrixClient, proxyUrl: string): SlidingSync {
-    manager = new SlidingSyncManager(client, proxyUrl);
-    return manager.slidingSync;
-}
diff --git a/src/components/structures/RoomView.tsx b/src/components/structures/RoomView.tsx
index 9f4f312ab23..9d6235ef627 100644
--- a/src/components/structures/RoomView.tsx
+++ b/src/components/structures/RoomView.tsx
@@ -110,7 +110,7 @@ import { DoAfterSyncPreparedPayload } from '../../dispatcher/payloads/DoAfterSyn
 import FileDropTarget from './FileDropTarget';
 import Measured from '../views/elements/Measured';
 import { FocusComposerPayload } from '../../dispatcher/payloads/FocusComposerPayload';
-import { getSlidingSyncManager } from '../../SlidingSyncManager';
+import { SlidingSyncManager } from '../../SlidingSyncManager';
 import { haveRendererForEvent } from "../../events/EventTileFactory";
 
 const DEBUG = false;
@@ -410,7 +410,7 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
         if (initial && SettingsStore.getValue("feature_sliding_sync")) {
             // set this room as the room subscription. We need to await for it as this will fetch
             // all room state for this room, which is required before we get the state below.
-            await getSlidingSyncManager().setRoomVisible(roomId, true);
+            await SlidingSyncManager.instance.setRoomVisible(roomId, true);
         }
 
         // This convoluted type signature ensures we get IntelliSense *and* correct typing
@@ -726,7 +726,7 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
 
         if (SettingsStore.getValue("feature_sliding_sync")) {
             // unsubscribe from this room, but don't await it as we don't care when this gets done.
-            getSlidingSyncManager().setRoomVisible(this.state.roomId, false);
+            SlidingSyncManager.instance.setRoomVisible(this.state.roomId, false);
         }
 
         // stop tracking room changes to format permalinks
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index 0d6cf859138..2c807613230 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -17,6 +17,7 @@ limitations under the License.
 import * as fbEmitter from "fbemitter";
 import { EventType, RoomType } from "matrix-js-sdk/src/@types/event";
 import { Room } from "matrix-js-sdk/src/models/room";
+import { MSC3575Filter } from "matrix-js-sdk/src/sliding-sync";
 import React, { ComponentType, createRef, ReactComponentElement, RefObject } from "react";
 
 import { IState as IRovingTabIndexState, RovingTabIndexProvider } from "../../../accessibility/RovingTabIndex";
@@ -607,13 +608,14 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
     }
 
     private renderSlidingSyncLists(): React.ReactElement[] {
+        // TODO: Currently sliding sync does not support Favourites, Low Priority or Server Notice groupings.
         const tagOrder = [
             DefaultTagID.Invite,
             // DefaultTagID.Favourite,
             DefaultTagID.DM,
             DefaultTagID.Untagged,
         ];
-        const tagToSlidingSyncFilters = {
+        const tagToSlidingSyncFilters: Record<string,MSC3575Filter> = {
             [DefaultTagID.Invite]: {
                 is_invite: true,
             },
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index ce5bd73e372..d478c391d53 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -17,7 +17,7 @@ limitations under the License.
 */
 
 import { Room } from "matrix-js-sdk/src/models/room";
-import { SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
+import { MSC3575Filter, SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import classNames from 'classnames';
 import { Dispatcher } from "flux";
 import { Enable, Resizable } from "re-resizable";
@@ -54,7 +54,7 @@ import AccessibleButton from "../../views/elements/AccessibleButton";
 import AccessibleTooltipButton from "../elements/AccessibleTooltipButton";
 import ExtraTile from "./ExtraTile";
 import SettingsStore from "../../../settings/SettingsStore";
-import { getSlidingSyncManager } from "../../../SlidingSyncManager";
+import { SlidingSyncManager } from "../../../SlidingSyncManager";
 import { MatrixClientPeg } from "../../../MatrixClientPeg";
 import NotificationBadge from "./NotificationBadge";
 import RoomTile from "./RoomTile";
@@ -92,7 +92,7 @@ interface IProps {
     forceExpanded?: boolean;
     resizeNotifier: ResizeNotifier;
     extraTiles?: ReactComponentElement<typeof ExtraTile>[];
-    slidingSyncFilter?: object; // request JSON for the 'filters' object.
+    slidingSyncFilter?: MSC3575Filter; // request JSON for the 'filters' object.
     slidingSyncIndex?: number; // the list index for this sublist
     onListCollapse?: (isExpanded: boolean) => void;
 }
@@ -133,7 +133,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         this.slidingSyncMode = SettingsStore.getValue("feature_sliding_sync");
         if (this.slidingSyncMode) {
             this.onSlidingSyncListUpdate = this.onSlidingSyncListUpdate.bind(this);
-            this.slidingSyncInit = getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
+            this.slidingSyncInit = SlidingSyncManager.instance.ensureListRegistered(this.props.slidingSyncIndex, {
                 filters: this.props.slidingSyncFilter,
                 sort: SlidingSyncSortToFilter[SortAlgorithm.Recent], // default to recency sort
             });
@@ -279,9 +279,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         RoomListStore.instance.on(LISTS_UPDATE_EVENT, this.onListsUpdated);
         if (this.slidingSyncMode) {
             // listen for updates to this list
-            getSlidingSyncManager().slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
+            SlidingSyncManager.instance.slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
             // fire the list data for the initial render
-            const listData = getSlidingSyncManager().slidingSync.getListData(this.props.slidingSyncIndex);
+            const listData = SlidingSyncManager.instance.slidingSync.getListData(this.props.slidingSyncIndex);
             this.onSlidingSyncListUpdate(this.props.slidingSyncIndex, listData.joinedCount, listData.roomIndexToRoomId);
         }
 
@@ -293,7 +293,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     public componentWillUnmount() {
         defaultDispatcher.unregister(this.dispatcherRef);
         if (this.slidingSyncMode) {
-            getSlidingSyncManager().slidingSync.off(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
+            SlidingSyncManager.instance.slidingSync.off(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
         }
         RoomListStore.instance.off(LISTS_UPDATE_EVENT, this.onListsUpdated);
         this.tilesRef.current?.removeEventListener("scroll", this.onScrollPrevent);
@@ -331,7 +331,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
         if (this.props.forceExpanded && orderedRoomIds.length < joinCount) {
             // expand the range for this list as we are forcibly showing everything
-            getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
+            SlidingSyncManager.instance.ensureListRegistered(this.props.slidingSyncIndex, {
                 ranges: [
                     [0, joinCount-1],
                 ],
@@ -406,7 +406,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
     private onShowAllClick = async () => {
         if (this.slidingSyncMode) {
-            await getSlidingSyncManager().ensureListRegistered(this.props.slidingSyncIndex, {
+            await SlidingSyncManager.instance.ensureListRegistered(this.props.slidingSyncIndex, {
                 ranges: [
                     [0, this.state.slidingSyncJoinedCount-1],
                 ],
@@ -471,14 +471,14 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         if (this.slidingSyncMode) {
             switch (sort) {
                 case SortAlgorithm.Alphabetic:
-                    await getSlidingSyncManager().ensureListRegistered(
+                    await SlidingSyncManager.instance.ensureListRegistered(
                         this.props.slidingSyncIndex, {
                             sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic],
                         },
                     );
                     break;
                 case SortAlgorithm.Recent:
-                    await getSlidingSyncManager().ensureListRegistered(
+                    await SlidingSyncManager.instance.ensureListRegistered(
                         this.props.slidingSyncIndex, {
                             sort: SlidingSyncSortToFilter[SortAlgorithm.Recent],
                         },
@@ -655,7 +655,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             let isAlphabetical = RoomListStore.instance.getTagSorting(this.props.tagId) === SortAlgorithm.Alphabetic;
             let isUnreadFirst = RoomListStore.instance.getListOrder(this.props.tagId) === ListAlgorithm.Importance;
             if (this.slidingSyncMode) {
-                const slidingList = getSlidingSyncManager().slidingSync.getList(this.props.slidingSyncIndex);
+                const slidingList = SlidingSyncManager.instance.slidingSync.getList(this.props.slidingSyncIndex);
                 isAlphabetical = slidingList.sort[0] === "by_name";
                 isUnreadFirst = (
                     slidingList.sort[0] === "by_highlight_count" ||
diff --git a/src/hooks/useSlidingSyncRoomSearch.ts b/src/hooks/useSlidingSyncRoomSearch.ts
index 8de8b9bf5e6..85c1b328724 100644
--- a/src/hooks/useSlidingSyncRoomSearch.ts
+++ b/src/hooks/useSlidingSyncRoomSearch.ts
@@ -19,7 +19,7 @@ import { Room } from "matrix-js-sdk/src/models/room";
 
 import { MatrixClientPeg } from "../MatrixClientPeg";
 import { useLatestResult } from "./useLatestResult";
-import { getSlidingSyncManager } from "../SlidingSyncManager";
+import { SlidingSyncManager } from "../SlidingSyncManager";
 
 export interface ISlidingSyncRoomSearchOpts {
     limit: number;
@@ -30,7 +30,7 @@ export const useSlidingSyncRoomSearch = () => {
     const [rooms, setRooms] = useState<Room[]>([]);
 
     const [loading, setLoading] = useState(false);
-    const listIndex = getSlidingSyncManager().getSearchListIndex();
+    const listIndex = SlidingSyncManager.instance.getSearchListIndex();
 
     const [updateQuery, updateResult] = useLatestResult<{ term: string, limit?: number }, Room[]>(setRooms);
 
@@ -48,14 +48,14 @@ export const useSlidingSyncRoomSearch = () => {
 
         try {
             setLoading(true);
-            await getSlidingSyncManager().ensureListRegistered(listIndex, {
+            await SlidingSyncManager.instance.ensureListRegistered(listIndex, {
                 ranges: [[0, limit]],
                 filters: {
                     room_name_like: term,
                 },
             });
             const rooms = [];
-            const { roomIndexToRoomId } = getSlidingSyncManager().slidingSync.getListData(listIndex);
+            const { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(listIndex);
             let i = 0;
             while (roomIndexToRoomId[i]) {
                 const roomId = roomIndexToRoomId[i];
diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
index b874430d06a..c351e9b5b7f 100644
--- a/src/settings/controllers/SlidingSyncController.ts
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -21,6 +21,7 @@ import PlatformPeg from "../../PlatformPeg";
 import { SettingLevel } from "../SettingLevel";
 import SdkConfig from "../../SdkConfig";
 import SettingsStore from "../SettingsStore";
+import { MatrixClientPeg } from "../../MatrixClientPeg";
 
 export default class SlidingSyncController extends SettingController {
     public async onChange(level: SettingLevel, roomId: string, newValue: any) {
@@ -32,9 +33,9 @@ export default class SlidingSyncController extends SettingController {
                 return;
             }
             try {
-                await proxyHealthCheck(url);
+                await proxyHealthCheck(url, MatrixClientPeg.get().baseUrl);
             } catch (err) {
-                console.error(err);
+                logger.error("sliding sync proxy not ok: " + err);
                 // force the value to false, this is a bit ew, it would be nice if we could return
                 // a bool as to whether to go through with the change or not.
                 SettingsStore.setValue("feature_sliding_sync", roomId, level, false);
@@ -53,32 +54,23 @@ export default class SlidingSyncController extends SettingController {
  * Check that the proxy url is in fact a sliding sync proxy endpoint and it is up.
  * @param endpoint The proxy endpoint url
  * @param hsUrl The homeserver url of the logged in user.
- * @returns True if the proxy is valid, else throws.
+ * @throws if the proxy server is unreachable or not configured to the given homeserver
  */
-function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<boolean> {
+async function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<any> {
     // TODO: when HSes natively support sliding sync, we should just hit the /sync endpoint to see
     // if it 200 OKs.
-    return new Promise<boolean>((resolve, reject) => {
-        const req = new XMLHttpRequest();
-        req.open("GET", endpoint + "/client/server.json");
-        req.responseType = "json";
-        req.timeout = 10 * 1000;
-        req.onreadystatechange = function() {
-            if (req.readyState !== XMLHttpRequest.DONE) {
-                return;
-            }
-            if (req.status !== 200) {
-                reject(new Error(`HTTP ${req.status}`));
-                return;
-            }
-            // The proxy is hard-coded on startup to talk to a single HS. Make sure that HS matches
-            // the client's HS else we might give an access_token to a different homeserver!
-            if (hsUrl && hsUrl !== req.response.server) {
-                reject(new Error("homeserver mismatch: client="+hsUrl+" proxy="+req.response.server));
-                return;
-            }
-            resolve(true);
-        };
-        req.send();
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), 10 * 1000); // 10s
+    const res = await fetch(endpoint + "/client/server.json", {
+        signal: controller.signal,
     });
+    clearTimeout(id);
+    if (res.status != 200) {
+        throw new Error(`proxyHealthCheck: proxy server returned HTTP ${res.status}`);
+    }
+    const body = await res.json();
+    if (body.server !== hsUrl) {
+        throw new Error(`proxyHealthCheck: client using ${hsUrl} but server is as ${body.server}`);
+    }
+    logger.info("sliding sync proxy is OK");
 }

From 8f818e4d3ec54a21c76fc936a87cd6b482c6ac59 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 21 Jul 2022 10:47:04 +0100
Subject: [PATCH 26/81] Use RoomViewStore to set room subscriptions

---
 src/SlidingSyncManager.ts              | 14 +++++++++++--
 src/components/structures/RoomView.tsx | 12 -----------
 src/stores/RoomViewStore.tsx           | 29 ++++++++++++++++++++++++++
 3 files changed, 41 insertions(+), 14 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 66dee5abed4..c0cde13516b 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -79,7 +79,14 @@ export class SlidingSyncManager {
     private client: MatrixClient;
     private searchListIndex: number;
 
-    constructor(){}
+    private configurePromise: Promise<void>;
+    private configureResolve: Function;
+
+    constructor(){
+        this.configurePromise = new Promise((resolve) => {
+            this.configureResolve = resolve;
+        });
+    }
 
     public static get instance(): SlidingSyncManager {
         return SlidingSyncManager.internalInstance;
@@ -91,6 +98,7 @@ export class SlidingSyncManager {
         );
         this.client = client;
         this.searchListIndex = undefined;
+        this.configureResolve();
         return this.slidingSync;
     }
 
@@ -116,6 +124,7 @@ export class SlidingSyncManager {
         listIndex: number, updateArgs: PartialSlidingSyncRequest,
     ): Promise<MSC3575List> {
         logger.debug("ensureListRegistered", listIndex, updateArgs);
+        await this.configurePromise;
         let list = this.slidingSync.getList(listIndex);
         if (!list) {
             list = {
@@ -162,7 +171,8 @@ export class SlidingSyncManager {
         });
     }
 
-    setRoomVisible(roomId: string, visible: boolean): Promise<string> {
+    async setRoomVisible(roomId: string, visible: boolean): Promise<string> {
+        await this.configurePromise;
         const subscriptions = this.slidingSync.getRoomSubscriptions();
         if (visible) {
             subscriptions.add(roomId);
diff --git a/src/components/structures/RoomView.tsx b/src/components/structures/RoomView.tsx
index 9d6235ef627..0bc25a38dc0 100644
--- a/src/components/structures/RoomView.tsx
+++ b/src/components/structures/RoomView.tsx
@@ -110,7 +110,6 @@ import { DoAfterSyncPreparedPayload } from '../../dispatcher/payloads/DoAfterSyn
 import FileDropTarget from './FileDropTarget';
 import Measured from '../views/elements/Measured';
 import { FocusComposerPayload } from '../../dispatcher/payloads/FocusComposerPayload';
-import { SlidingSyncManager } from '../../SlidingSyncManager';
 import { haveRendererForEvent } from "../../events/EventTileFactory";
 
 const DEBUG = false;
@@ -407,12 +406,6 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
 
         const roomId = RoomViewStore.instance.getRoomId();
 
-        if (initial && SettingsStore.getValue("feature_sliding_sync")) {
-            // set this room as the room subscription. We need to await for it as this will fetch
-            // all room state for this room, which is required before we get the state below.
-            await SlidingSyncManager.instance.setRoomVisible(roomId, true);
-        }
-
         // This convoluted type signature ensures we get IntelliSense *and* correct typing
         const newState: Partial<IRoomState> & Pick<IRoomState, any> = {
             roomId,
@@ -724,11 +717,6 @@ export class RoomView extends React.Component<IRoomProps, IRoomState> {
             this.context.stopPeeking();
         }
 
-        if (SettingsStore.getValue("feature_sliding_sync")) {
-            // unsubscribe from this room, but don't await it as we don't care when this gets done.
-            SlidingSyncManager.instance.setRoomVisible(this.state.roomId, false);
-        }
-
         // stop tracking room changes to format permalinks
         this.stopAllPermalinkCreators();
 
diff --git a/src/stores/RoomViewStore.tsx b/src/stores/RoomViewStore.tsx
index ea2b7e93ad2..b153e333335 100644
--- a/src/stores/RoomViewStore.tsx
+++ b/src/stores/RoomViewStore.tsx
@@ -48,6 +48,8 @@ import { JoinRoomErrorPayload } from "../dispatcher/payloads/JoinRoomErrorPayloa
 import { ViewRoomErrorPayload } from "../dispatcher/payloads/ViewRoomErrorPayload";
 import ErrorDialog from "../components/views/dialogs/ErrorDialog";
 import { ActiveRoomChangedPayload } from "../dispatcher/payloads/ActiveRoomChangedPayload";
+import SettingsStore from "../settings/SettingsStore";
+import { SlidingSyncManager } from "../SlidingSyncManager";
 
 const NUM_JOIN_RETRY = 5;
 
@@ -289,6 +291,33 @@ export class RoomViewStore extends Store<ActionPayload> {
                     activeSpace,
                 });
             }
+            if (SettingsStore.getValue("feature_sliding_sync") && this.state.roomId !== payload.room_id) {
+                if (this.state.roomId) {
+                    // unsubscribe from this room, but don't await it as we don't care when this gets done.
+                    SlidingSyncManager.instance.setRoomVisible(this.state.roomId, false);
+                }
+                this.setState({
+                    roomId: payload.room_id,
+                    initialEventId: null,
+                    initialEventPixelOffset: null,
+                    isInitialEventHighlighted: null,
+                    initialEventScrollIntoView: true,
+                    roomAlias: null,
+                    roomLoading: true,
+                    roomLoadError: null,
+                    viaServers: payload.via_servers,
+                    wasContextSwitch: payload.context_switch,
+                });
+                // set this room as the room subscription. We need to await for it as this will fetch
+                // all room state for this room, which is required before we get the state below.
+                await SlidingSyncManager.instance.setRoomVisible(payload.room_id, true);
+                // Re-fire the payload: we won't re-process it because the prev room ID == payload room ID now
+                dis.dispatch({
+                    ...payload,
+                });
+                return;
+            }
+
 
             const newState = {
                 roomId: payload.room_id,

From 050903d1f4b9dda87e1c5f8f8f5ea6f4251a96a6 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 21 Jul 2022 10:49:13 +0100
Subject: [PATCH 27/81] Comment why any

---
 src/components/views/rooms/RoomSublist.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index d478c391d53..2897b460eb0 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -125,7 +125,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     private notificationState: ListNotificationState;
 
     private slidingSyncMode: boolean;
-    private slidingSyncInit: Promise<any>;
+    private slidingSyncInit: Promise<any>; // we don't care about the resulting list, hence 'any'
 
     constructor(props: IProps) {
         super(props);

From 64d941eb17f46b629e5f676e0cd7884b23af6957 Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Tue, 26 Jul 2022 09:31:43 +0100
Subject: [PATCH 28/81] Update src/components/views/rooms/RoomSublist.tsx

Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>
---
 src/components/views/rooms/RoomSublist.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 2897b460eb0..17ff1edb0c7 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -125,7 +125,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     private notificationState: ListNotificationState;
 
     private slidingSyncMode: boolean;
-    private slidingSyncInit: Promise<any>; // we don't care about the resulting list, hence 'any'
+    private slidingSyncInit: Promise<unknown>; // we don't care about the resulting list
 
     constructor(props: IProps) {
         super(props);

From 332b136998d10fa9a570f401fc6cb03cf2e9efce Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 27 Jul 2022 17:41:16 +0100
Subject: [PATCH 29/81] Fix cypress docker abstraction

---
 cypress/plugins/docker/index.ts        | 27 +++++++++++++++-----------
 cypress/plugins/synapsedocker/index.ts |  3 ++-
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/cypress/plugins/docker/index.ts b/cypress/plugins/docker/index.ts
index 2f3c6464083..25c556a5273 100644
--- a/cypress/plugins/docker/index.ts
+++ b/cypress/plugins/docker/index.ts
@@ -17,6 +17,7 @@ limitations under the License.
 /// <reference types="cypress" />
 
 import * as os from "os";
+import * as crypto from "crypto";
 import * as childProcess from "child_process";
 import * as fse from "fs-extra";
 
@@ -25,28 +26,32 @@ import PluginConfigOptions = Cypress.PluginConfigOptions;
 
 // A cypress plugin to run docker commands
 
-export function dockerRun(args: {
+export function dockerRun(opts: {
     image: string;
     containerName: string;
     params?: string[];
+    cmd?: string;
 }): Promise<string> {
     const userInfo = os.userInfo();
-    const params = args.params ?? [];
+    const params = opts.params ?? [];
 
-    if (userInfo.uid >= 0) {
+    if (params?.includes("-v") && userInfo.uid >= 0) {
         // On *nix we run the docker container as our uid:gid otherwise cleaning it up its media_store can be difficult
         params.push("-u", `${userInfo.uid}:${userInfo.gid}`);
     }
 
+    const args = [
+        "run",
+        "--name", `${opts.containerName}-${crypto.randomBytes(4).toString("hex")}`,
+        "-d",
+        ...params,
+        opts.image,
+    ];
+
+    if (opts.cmd) args.push(opts.cmd);
+
     return new Promise<string>((resolve, reject) => {
-        childProcess.execFile('docker', [
-            "run",
-            "--name", args.containerName,
-            "-d",
-            ...params,
-            args.image,
-            "run",
-        ], (err, stdout) => {
+        childProcess.execFile("docker", args, (err, stdout) => {
             if (err) reject(err);
             resolve(stdout.trim());
         });
diff --git a/cypress/plugins/synapsedocker/index.ts b/cypress/plugins/synapsedocker/index.ts
index 5227b5e4ac8..bfbda1e3607 100644
--- a/cypress/plugins/synapsedocker/index.ts
+++ b/cypress/plugins/synapsedocker/index.ts
@@ -101,12 +101,13 @@ async function synapseStart(template: string): Promise<SynapseInstance> {
 
     const synapseId = await dockerRun({
         image: "matrixdotorg/synapse:develop",
-        containerName: `react-sdk-cypress-synapse-${crypto.randomBytes(4).toString("hex")}`,
+        containerName: `react-sdk-cypress-synapse`,
         params: [
             "--rm",
             "-v", `${synCfg.configDir}:/data`,
             "-p", `${synCfg.port}:8008/tcp`,
         ],
+        cmd: "run",
     });
 
     console.log(`Started synapse with id ${synapseId} on port ${synCfg.port}.`);

From 1ba5bf54694401398faa32bfafa72378506772fd Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 27 Jul 2022 17:41:42 +0100
Subject: [PATCH 30/81] Iterate sliding sync proxy support

---
 cypress/plugins/docker/index.ts       | 16 ++++++++
 cypress/plugins/sliding-sync/index.ts | 32 +++++++++++----
 cypress/support/e2e.ts                |  1 +
 cypress/support/proxy.ts              | 58 +++++++++++++++++++++++++++
 4 files changed, 99 insertions(+), 8 deletions(-)
 create mode 100644 cypress/support/proxy.ts

diff --git a/cypress/plugins/docker/index.ts b/cypress/plugins/docker/index.ts
index 25c556a5273..874d7a8b575 100644
--- a/cypress/plugins/docker/index.ts
+++ b/cypress/plugins/docker/index.ts
@@ -122,6 +122,21 @@ export function dockerRm(args: {
     });
 }
 
+export function dockerIp(args: {
+    containerId: string;
+}): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+        childProcess.execFile('docker', [
+            "inspect",
+            "-f", "{{ .NetworkSettings.IPAddress }}",
+            args.containerId,
+        ], (err, stdout) => {
+            if (err) reject(err);
+            else resolve(stdout);
+        });
+    });
+}
+
 /**
  * @type {Cypress.PluginConfig}
  */
@@ -132,5 +147,6 @@ export function docker(on: PluginEvents, config: PluginConfigOptions) {
         dockerLogs,
         dockerStop,
         dockerRm,
+        dockerIp,
     });
 }
diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index c51d9209840..dd620db97ad 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -18,18 +18,20 @@ limitations under the License.
 
 import PluginEvents = Cypress.PluginEvents;
 import PluginConfigOptions = Cypress.PluginConfigOptions;
-import { dockerRun, dockerStop } from "../docker";
+import { dockerIp, dockerRun, dockerStop } from "../docker";
 import { getFreePort } from "../utils/port";
 import { SynapseInstance } from "../synapsedocker";
 
 // A cypress plugins to add command to start & stop https://github.com/matrix-org/sliding-sync
 
-interface ProxyInstance {
+export interface ProxyInstance {
     containerId: string;
     postgresId: string;
     port: number;
 }
 
+const instances = new Map<string, ProxyInstance>();
+
 const POSTGRES_PASSWORD = "p4S5w0rD";
 
 async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
@@ -39,25 +41,30 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
         image: "postgres",
         containerName: "react-sdk-cypress-sliding-sync-postgres",
         params: [
+            "--rm",
             "-e", `POSTGRES_PASSWORD=${POSTGRES_PASSWORD}`,
         ],
     });
 
+    const ip = await dockerIp({ containerId: postgresId });
+
+    await new Promise(resolve => setTimeout(resolve, 5000));
+
     const port = await getFreePort();
     const containerId = await dockerRun({
-        image: "ghcr.io/matrix-org/sliding-sync-proxy",
+        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.1.4",
         containerName: "react-sdk-cypress-sliding-sync-proxy",
         params: [
             "--rm",
             "-p", `${port}:8008/tcp`,
-            "--network", postgresId,
-            "-e", `SYNCV3_SERVER=${synapse.baseUrl}`,
-            "-e", `SYNCV3_DB="user=postgres dbname=postgres password=${POSTGRES_PASSWORD} ` +
-                `host=react-sdk-cypress-sliding-sync-postgres sslmode=disable"`,
+            "-e", `SYNCV3_SERVER=172.17.0.1:${synapse.port}`,
+            "-e", `SYNCV3_DB=user=postgres dbname=postgres password=${POSTGRES_PASSWORD} host=${ip} sslmode=disable`,
         ],
     });
 
-    return { containerId, postgresId, port };
+    const instance: ProxyInstance = { containerId, postgresId, port };
+    instances.set(containerId, instance);
+    return instance;
 }
 
 async function proxyStop(instance: ProxyInstance): Promise<void> {
@@ -68,6 +75,8 @@ async function proxyStop(instance: ProxyInstance): Promise<void> {
         containerId: instance.postgresId,
     });
 
+    instances.delete(instance.containerId);
+
     console.log("Stopped sliding sync proxy.");
     // cypress deliberately fails if you return 'undefined', so
     // return null to signal all is well, and we've handled the task.
@@ -82,4 +91,11 @@ export function slidingSyncProxyDocker(on: PluginEvents, config: PluginConfigOpt
         proxyStart,
         proxyStop,
     });
+
+    on("after:spec", async (spec) => {
+        for (const instance of instances.values()) {
+            console.warn(`Cleaning up proxy on port ${instance.port} after ${spec.name}`);
+            await proxyStop(instance);
+        }
+    });
 }
diff --git a/cypress/support/e2e.ts b/cypress/support/e2e.ts
index faff9a83637..8df28f9a625 100644
--- a/cypress/support/e2e.ts
+++ b/cypress/support/e2e.ts
@@ -36,3 +36,4 @@ import "./iframes";
 import "./timeline";
 import "./network";
 import "./composer";
+import "./proxy";
diff --git a/cypress/support/proxy.ts b/cypress/support/proxy.ts
new file mode 100644
index 00000000000..e6b1ae96f1d
--- /dev/null
+++ b/cypress/support/proxy.ts
@@ -0,0 +1,58 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/// <reference types="cypress" />
+
+import Chainable = Cypress.Chainable;
+import AUTWindow = Cypress.AUTWindow;
+import { ProxyInstance } from '../plugins/sliding-sync';
+import { SynapseInstance } from "../plugins/synapsedocker";
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace Cypress {
+        interface Chainable {
+            /**
+             * Start a sliding sync proxy instance.
+             * @param synapse the synapse instance returned by startSynapse
+             */
+            startProxy(synapse: SynapseInstance): Chainable<ProxyInstance>;
+
+            /**
+             * Custom command wrapping task:proxyStop whilst preventing uncaught exceptions
+             * for if Docker stopping races with the app's background sync loop.
+             * @param proxy the proxy instance returned by startProxy
+             */
+            stopProxy(proxy: ProxyInstance): Chainable<AUTWindow>;
+        }
+    }
+}
+
+function startProxy(synapse: SynapseInstance): Chainable<ProxyInstance> {
+    return cy.task<ProxyInstance>("proxyStart", synapse);
+}
+
+function stopProxy(proxy?: ProxyInstance): Chainable<AUTWindow> {
+    if (!proxy) return;
+    // Navigate away from app to stop the background network requests which will race with Synapse shutting down
+    return cy.window({ log: false }).then((win) => {
+        win.location.href = 'about:blank';
+        cy.task("proxyStop", proxy);
+    });
+}
+
+Cypress.Commands.add("startProxy", startProxy);
+Cypress.Commands.add("stopProxy", stopProxy);

From 05425895709d53eb97d24a49ae135a5d1a2f43bd Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 27 Jul 2022 18:12:54 +0100
Subject: [PATCH 31/81] Stash mostly functional test

---
 cypress/e2e/sliding-sync/sliding-sync.ts | 68 ++++++++++++++++++++++++
 cypress/plugins/docker/index.ts          |  2 +-
 cypress/plugins/sliding-sync/index.ts    | 11 ++--
 3 files changed, 75 insertions(+), 6 deletions(-)
 create mode 100644 cypress/e2e/sliding-sync/sliding-sync.ts

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
new file mode 100644
index 00000000000..534b9ac0df5
--- /dev/null
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -0,0 +1,68 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/// <reference types="cypress" />
+
+import { SynapseInstance } from "../../plugins/synapsedocker";
+import { SettingLevel } from "../../../src/settings/SettingLevel";
+import { Layout } from "../../../src/settings/enums/Layout";
+import { ProxyInstance } from "../../plugins/sliding-sync";
+
+describe("Sliding Sync", () => {
+    beforeEach(() => {
+        cy.startSynapse("default").as("synapse").then(synapse => {
+            cy.startProxy(synapse).as("proxy");
+        });
+
+        cy.all([
+            cy.get<SynapseInstance>("@synapse"),
+            cy.get<ProxyInstance>("@proxy"),
+        ]).then(([synapse, proxy]) => {
+            cy.enableLabsFeature("feature_sliding_sync");
+
+            cy.intercept("/config.json?cachebuster=*", req => {
+                req.continue(res => {
+                    res.send(200, {
+                        ...res.body,
+                        sliding_sync_proxy_url: `http://localhost:${proxy.port}`,
+                    });
+                });
+            });
+
+            cy.initTestUser(synapse, "Sloth").then(() =>
+                cy.window({ log: false }).then(() => {
+                    cy.createRoom({ name: "Test Room" }).as("roomId");
+                }),
+            );
+        });
+    });
+
+    it("should correctly render expected messages", () => {
+        cy.get<string>("@room").then(roomId => cy.visit("/#/room/" + roomId));
+        cy.setSettingValue("layout", null, SettingLevel.DEVICE, Layout.IRC);
+
+        // Wait until configuration is finished
+        cy.contains(
+            ".mx_RoomView_body .mx_GenericEventListSummary .mx_GenericEventListSummary_summary",
+            "created and configured the room.",
+        );
+
+        // Click "expand" link button
+        cy.get(".mx_GenericEventListSummary_toggle[aria-expanded=false]").click();
+
+        cy.pause();
+    });
+});
diff --git a/cypress/plugins/docker/index.ts b/cypress/plugins/docker/index.ts
index 874d7a8b575..46d363b40d0 100644
--- a/cypress/plugins/docker/index.ts
+++ b/cypress/plugins/docker/index.ts
@@ -132,7 +132,7 @@ export function dockerIp(args: {
             args.containerId,
         ], (err, stdout) => {
             if (err) reject(err);
-            else resolve(stdout);
+            else resolve(stdout.trim());
         });
     });
 }
diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index dd620db97ad..16090839b8f 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -32,7 +32,7 @@ export interface ProxyInstance {
 
 const instances = new Map<string, ProxyInstance>();
 
-const POSTGRES_PASSWORD = "p4S5w0rD";
+const PG_PASSWORD = "p4S5w0rD";
 
 async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
     console.log("Starting sliding sync proxy...");
@@ -42,11 +42,12 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
         containerName: "react-sdk-cypress-sliding-sync-postgres",
         params: [
             "--rm",
-            "-e", `POSTGRES_PASSWORD=${POSTGRES_PASSWORD}`,
+            "-e", `POSTGRES_PASSWORD=${PG_PASSWORD}`,
         ],
     });
 
-    const ip = await dockerIp({ containerId: postgresId });
+    const postgresIp = await dockerIp({ containerId: postgresId });
+    const synapseIp = await dockerIp({ containerId: synapse.synapseId });
 
     await new Promise(resolve => setTimeout(resolve, 5000));
 
@@ -57,8 +58,8 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
         params: [
             "--rm",
             "-p", `${port}:8008/tcp`,
-            "-e", `SYNCV3_SERVER=172.17.0.1:${synapse.port}`,
-            "-e", `SYNCV3_DB=user=postgres dbname=postgres password=${POSTGRES_PASSWORD} host=${ip} sslmode=disable`,
+            "-e", `SYNCV3_SERVER=http://${synapseIp}:8008`,
+            "-e", `SYNCV3_DB=user=postgres dbname=postgres password=${PG_PASSWORD} host=${postgresIp} sslmode=disable`,
         ],
     });
 

From be146efe62b3b732d5ff533721dd0df3c044e4d5 Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 27 Jul 2022 18:31:50 +0100
Subject: [PATCH 32/81] Update sliding sync proxy image

---
 cypress/plugins/sliding-sync/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index 16090839b8f..47732aae5eb 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -53,7 +53,7 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
 
     const port = await getFreePort();
     const containerId = await dockerRun({
-        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.1.4",
+        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.2.0",
         containerName: "react-sdk-cypress-sliding-sync-proxy",
         params: [
             "--rm",

From 2ed801def86c67946b3633334ae8071f8fa2bb05 Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 27 Jul 2022 18:35:15 +0100
Subject: [PATCH 33/81] i18n

---
 src/i18n/strings/en_EN.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json
index dacf1068006..24724216d69 100644
--- a/src/i18n/strings/en_EN.json
+++ b/src/i18n/strings/en_EN.json
@@ -899,6 +899,7 @@
     "Right panel stays open (defaults to room member list)": "Right panel stays open (defaults to room member list)",
     "Jump to date (adds /jumptodate and jump to date headers)": "Jump to date (adds /jumptodate and jump to date headers)",
     "Don't send read receipts": "Don't send read receipts",
+    "Sliding Sync mode (under active development)": "Sliding Sync mode (under active development)",
     "Right-click message context menu": "Right-click message context menu",
     "Location sharing - pin drop": "Location sharing - pin drop",
     "Live Location Sharing (temporary implementation: locations persist in room history)": "Live Location Sharing (temporary implementation: locations persist in room history)",
@@ -953,7 +954,6 @@
     "Show shortcuts to recently viewed rooms above the room list": "Show shortcuts to recently viewed rooms above the room list",
     "Show hidden events in timeline": "Show hidden events in timeline",
     "Low bandwidth mode (requires compatible homeserver)": "Low bandwidth mode (requires compatible homeserver)",
-    "Sliding Sync mode (under active development)": "Sliding Sync mode (under active development)",
     "Allow fallback call assist server turn.matrix.org when your homeserver does not offer one (your IP address would be shared during a call)": "Allow fallback call assist server turn.matrix.org when your homeserver does not offer one (your IP address would be shared during a call)",
     "Show previews/thumbnails for images": "Show previews/thumbnails for images",
     "Enable message search in encrypted rooms": "Enable message search in encrypted rooms",

From da4001ff9f3e6b0918fd7df4c8ea94dfec03d048 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 2 Aug 2022 13:46:56 +0100
Subject: [PATCH 34/81] Add support for spaces; use list ID -> index mappings

- Mappings are more reusable and easier to understand than
  racing for index positions.
- Register for all spaces immediately on startup.
---
 src/SlidingSyncManager.ts                  | 55 ++++++++++++++++++----
 src/components/views/rooms/RoomList.tsx    |  2 +-
 src/components/views/rooms/RoomSublist.tsx | 25 ++++++----
 src/hooks/useSlidingSyncRoomSearch.ts      |  2 +-
 4 files changed, 62 insertions(+), 22 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index c0cde13516b..4e6ddcf94f1 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -73,16 +73,19 @@ export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[
  * sync options and code.
  */
 export class SlidingSyncManager {
+    public static ListSpaces = "space_list";
+    public static ListSearch = "search_list";
     private static internalInstance = new SlidingSyncManager();
 
     public slidingSync: SlidingSync;
     private client: MatrixClient;
-    private searchListIndex: number;
+    private listIdToIndex: Record<string,number>;
 
     private configurePromise: Promise<void>;
     private configureResolve: Function;
 
     constructor(){
+        this.listIdToIndex = {};
         this.configurePromise = new Promise((resolve) => {
             this.configureResolve = resolve;
         });
@@ -93,25 +96,57 @@ export class SlidingSyncManager {
     }
 
     public configure(client: MatrixClient, proxyUrl: string): SlidingSync {
+        this.client = client;
+        this.listIdToIndex = {};
         this.slidingSync = new SlidingSync(
             proxyUrl, [], DEFAULT_ROOM_SUBSCRIPTION_INFO, client, SLIDING_SYNC_TIMEOUT_MS,
         );
-        this.client = client;
-        this.searchListIndex = undefined;
+        // set the space list
+        this.slidingSync.setList(this.getOrAllocateListIndex(SlidingSyncManager.ListSpaces), {
+            ranges: [[0, 20]],
+            sort: [
+                "by_name",
+            ],
+            slow_get_all_rooms: true,
+            timeline_limit: 0,
+            required_state: [
+                [EventType.RoomJoinRules, ""], // the public icon on the room list
+                [EventType.RoomAvatar, ""], // any room avatar
+                [EventType.RoomTombstone, ""], // lets JS SDK hide rooms which are dead
+                [EventType.RoomEncryption, ""], // lets rooms be configured for E2EE correctly
+                [EventType.RoomCreate, ""], // for isSpaceRoom checks
+                [EventType.SpaceChild, "*"], // all space children
+                [EventType.SpaceParent, "*"], // all space parents
+                [EventType.RoomMember, this.client.getUserId()], // lets the client calculate that we are in fact in the room
+            ],
+            filters: {
+              room_types: ["m.space"],
+            }
+        });
         this.configureResolve();
         return this.slidingSync;
     }
 
     /**
-     * Allocate and return a list index for searching rooms. This ensures that 1 list only is allocated
-     * for searching rooms in sliding sync. This must be called after room list indexes have been allocated.
-     * @returns The list index for searching rooms
+     * Allocate or retrieve the list index for an arbitrary list ID. For example SlidingSyncManager.ListSpaces
+     * @param listId A string which represents the list.
+     * @returns The index to use when registering lists or listening for callbacks.
      */
-    getSearchListIndex(): number {
-        if (!this.searchListIndex) {
-            this.searchListIndex = this.slidingSync.listLength();
+    public getOrAllocateListIndex(listId: string): number {
+        let index = this.listIdToIndex[listId];
+        if (index === undefined) {
+            // assign next highest index
+            index = -1;
+            for (const id in this.listIdToIndex) {
+                const listIndex = this.listIdToIndex[id];
+                if (listIndex > index) {
+                    index = listIndex;
+                }
+            }
+            index++;
+            this.listIdToIndex[listId] = index;
         }
-        return this.searchListIndex;
+        return index;
     }
 
     /**
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index f6fa04a0bc8..eeb30bb9385 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -678,7 +678,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
                 tagId={tag}
                 forRooms={true}
                 slidingSyncFilter={tagToSlidingSyncFilters[tag]}
-                slidingSyncIndex={index}
+                slidingSyncId={"list_"+index}
                 startAsHidden={aesthetics.defaultHidden}
                 label={aesthetics.sectionLabelRaw ? aesthetics.sectionLabelRaw : _t(aesthetics.sectionLabel)}
                 AuxButtonComponent={aesthetics.AuxButtonComponent}
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 5fa94a723a2..0d25a4f1463 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -93,7 +93,7 @@ interface IProps {
     resizeNotifier: ResizeNotifier;
     extraTiles?: ReactComponentElement<typeof ExtraTile>[];
     slidingSyncFilter?: MSC3575Filter; // request JSON for the 'filters' object.
-    slidingSyncIndex?: number; // the list index for this sublist
+    slidingSyncId?: string; // the list ID for this sublist
     onListCollapse?: (isExpanded: boolean) => void;
 }
 
@@ -133,7 +133,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         this.slidingSyncMode = SettingsStore.getValue("feature_sliding_sync");
         if (this.slidingSyncMode) {
             this.onSlidingSyncListUpdate = this.onSlidingSyncListUpdate.bind(this);
-            this.slidingSyncInit = SlidingSyncManager.instance.ensureListRegistered(this.props.slidingSyncIndex, {
+            this.slidingSyncInit = SlidingSyncManager.instance.ensureListRegistered(SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId), {
                 filters: this.props.slidingSyncFilter,
                 sort: SlidingSyncSortToFilter[SortAlgorithm.Recent], // default to recency sort
             });
@@ -281,8 +281,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             // listen for updates to this list
             SlidingSyncManager.instance.slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
             // fire the list data for the initial render
-            const listData = SlidingSyncManager.instance.slidingSync.getListData(this.props.slidingSyncIndex);
-            this.onSlidingSyncListUpdate(this.props.slidingSyncIndex, listData.joinedCount, listData.roomIndexToRoomId);
+            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+            const listData = SlidingSyncManager.instance.slidingSync.getListData(slidingSyncIndex);
+            this.onSlidingSyncListUpdate(slidingSyncIndex, listData.joinedCount, listData.roomIndexToRoomId);
         }
 
         // Using the passive option to not block the main thread
@@ -300,7 +301,8 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     }
 
     private onSlidingSyncListUpdate(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>) {
-        if (listIndex !== this.props.slidingSyncIndex) {
+        const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+        if (listIndex !== slidingSyncIndex) {
             return;
         }
 
@@ -331,7 +333,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
         if (this.props.forceExpanded && orderedRoomIds.length < joinCount) {
             // expand the range for this list as we are forcibly showing everything
-            SlidingSyncManager.instance.ensureListRegistered(this.props.slidingSyncIndex, {
+            SlidingSyncManager.instance.ensureListRegistered(slidingSyncIndex, {
                 ranges: [
                     [0, joinCount-1],
                 ],
@@ -406,7 +408,8 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
     private onShowAllClick = async () => {
         if (this.slidingSyncMode) {
-            await SlidingSyncManager.instance.ensureListRegistered(this.props.slidingSyncIndex, {
+            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+            await SlidingSyncManager.instance.ensureListRegistered(slidingSyncIndex, {
                 ranges: [
                     [0, this.state.slidingSyncJoinedCount-1],
                 ],
@@ -469,17 +472,18 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
     private onTagSortChanged = async (sort: SortAlgorithm) => {
         if (this.slidingSyncMode) {
+            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
             switch (sort) {
                 case SortAlgorithm.Alphabetic:
                     await SlidingSyncManager.instance.ensureListRegistered(
-                        this.props.slidingSyncIndex, {
+                        slidingSyncIndex, {
                             sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic],
                         },
                     );
                     break;
                 case SortAlgorithm.Recent:
                     await SlidingSyncManager.instance.ensureListRegistered(
-                        this.props.slidingSyncIndex, {
+                        slidingSyncIndex, {
                             sort: SlidingSyncSortToFilter[SortAlgorithm.Recent],
                         },
                     );
@@ -655,7 +659,8 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             let isAlphabetical = RoomListStore.instance.getTagSorting(this.props.tagId) === SortAlgorithm.Alphabetic;
             let isUnreadFirst = RoomListStore.instance.getListOrder(this.props.tagId) === ListAlgorithm.Importance;
             if (this.slidingSyncMode) {
-                const slidingList = SlidingSyncManager.instance.slidingSync.getList(this.props.slidingSyncIndex);
+                const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+                const slidingList = SlidingSyncManager.instance.slidingSync.getList(slidingSyncIndex);
                 isAlphabetical = slidingList.sort[0] === "by_name";
                 isUnreadFirst = (
                     slidingList.sort[0] === "by_highlight_count" ||
diff --git a/src/hooks/useSlidingSyncRoomSearch.ts b/src/hooks/useSlidingSyncRoomSearch.ts
index 85c1b328724..9fd2304b708 100644
--- a/src/hooks/useSlidingSyncRoomSearch.ts
+++ b/src/hooks/useSlidingSyncRoomSearch.ts
@@ -30,7 +30,7 @@ export const useSlidingSyncRoomSearch = () => {
     const [rooms, setRooms] = useState<Room[]>([]);
 
     const [loading, setLoading] = useState(false);
-    const listIndex = SlidingSyncManager.instance.getSearchListIndex();
+    const listIndex = SlidingSyncManager.instance.getOrAllocateListIndex(SlidingSyncManager.ListSearch);
 
     const [updateQuery, updateResult] = useLatestResult<{ term: string, limit?: number }, Room[]>(setRooms);
 

From af5018d0f03a6845ac2788cc4ec6fd2c3d479375 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 2 Aug 2022 14:14:39 +0100
Subject: [PATCH 35/81] When the active space is updated, update the list
 registration

---
 src/SlidingSyncManager.ts                  |  2 +-
 src/components/views/rooms/RoomList.tsx    |  1 +
 src/components/views/rooms/RoomSublist.tsx | 10 ++++++++++
 3 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 4e6ddcf94f1..06e4a958c4b 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -64,7 +64,7 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
     ],
 };
 
-export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[], ranges?: number[][] };
+export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[], ranges?: number[][], spaces?: string[] };
 
 /**
  * This class manages the entirety of sliding sync at a high UI/UX level. It controls the placement
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index eeb30bb9385..3062adc5d6a 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -669,6 +669,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
                 is_dm: false,
                 is_invite: false,
                 is_tombstoned: false,
+                spaces: SpaceStore.instance.activeSpaceRoom ? [SpaceStore.instance.activeSpaceRoom.roomId] : undefined,
             },
         };
         return tagOrder.map((tag, index) => {
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 0d25a4f1463..cf30a866f78 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -17,6 +17,7 @@ limitations under the License.
 */
 
 import { Room } from "matrix-js-sdk/src/models/room";
+import * as utils from "matrix-js-sdk/src/utils";
 import { MSC3575Filter, SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import classNames from 'classnames';
 import { Dispatcher } from "flux";
@@ -212,6 +213,15 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         if (RoomSublist.calcNumTiles(prevState.rooms, prevExtraTiles) !== this.numTiles) {
             this.setState({ height: this.calculateInitialHeight() });
         }
+        if (this.slidingSyncMode && !utils.deepCompare(prevProps.slidingSyncFilter.spaces, this.props.slidingSyncFilter.spaces)) {
+            // spaces filter has changed, update the registration
+            SlidingSyncManager.instance.ensureListRegistered(
+                SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId),
+                {
+                    spaces: this.props.slidingSyncFilter.spaces,
+                },
+            )
+        }
     }
 
     public shouldComponentUpdate(nextProps: Readonly<IProps>, nextState: Readonly<IState>): boolean {

From a72da801b9a68669e9a4f1b1e1ad593b53c6835d Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 2 Aug 2022 17:23:04 +0100
Subject: [PATCH 36/81] Set spaces filter in the correct place

---
 src/SlidingSyncManager.ts                  | 2 +-
 src/components/views/rooms/RoomSublist.tsx | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 06e4a958c4b..4e6ddcf94f1 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -64,7 +64,7 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
     ],
 };
 
-export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[], ranges?: number[][], spaces?: string[] };
+export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[], ranges?: number[][] };
 
 /**
  * This class manages the entirety of sliding sync at a high UI/UX level. It controls the placement
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index cf30a866f78..6431c83a95a 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -215,10 +215,12 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         }
         if (this.slidingSyncMode && !utils.deepCompare(prevProps.slidingSyncFilter.spaces, this.props.slidingSyncFilter.spaces)) {
             // spaces filter has changed, update the registration
+            const filters = this.props.slidingSyncFilter;
+            filters.spaces = this.props.slidingSyncFilter.spaces;
             SlidingSyncManager.instance.ensureListRegistered(
                 SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId),
                 {
-                    spaces: this.props.slidingSyncFilter.spaces,
+                    filters: filters,
                 },
             )
         }
@@ -324,7 +326,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         const orderedRoomIds = orderedRoomIndexes.map((i) => {
             const rid = roomIndexToRoomId[i];
             if (!rid) {
-                throw new Error("index " + i + " has no room ID");
+                throw new Error("index " + i + " has no room ID: Map => " + JSON.stringify(roomIndexToRoomId));
             }
             return rid;
         });

From f65637ddc3bd4cef75be15e579450189e94ee733 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 5 Aug 2022 12:49:40 +0100
Subject: [PATCH 37/81] Skeleton placeholder whilst loading the space

---
 src/components/views/rooms/RoomSublist.tsx | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 6431c83a95a..a89b1d0ffdd 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -114,6 +114,7 @@ interface IState {
     rooms: Room[];
     filteredExtraTiles?: ReactComponentElement<typeof ExtraTile>[];
     slidingSyncJoinedCount?: number;
+    slidingSyncLoading: boolean;
 }
 
 export default class RoomSublist extends React.Component<IProps, IState> {
@@ -153,6 +154,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 this.slidingSyncMode ? [] : arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || [])
             ),
             slidingSyncJoinedCount: 0,
+            slidingSyncLoading: false,
         };
         // Why Object.assign() and not this.state.height? Because TypeScript says no.
         this.state = Object.assign(this.state, { height: this.calculateInitialHeight() });
@@ -217,12 +219,19 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             // spaces filter has changed, update the registration
             const filters = this.props.slidingSyncFilter;
             filters.spaces = this.props.slidingSyncFilter.spaces;
+            this.setState({
+                slidingSyncLoading: true,
+            });
             SlidingSyncManager.instance.ensureListRegistered(
                 SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId),
                 {
                     filters: filters,
                 },
-            )
+            ).then(() => {
+                this.setState({
+                    slidingSyncLoading: false,
+                });
+            });
         }
     }
 
@@ -863,7 +872,9 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         });
 
         let content = null;
-        if (visibleTiles.length > 0 && this.props.forceExpanded) {
+        if (this.state.slidingSyncLoading) {
+            content = <div className="mx_RoomSublist_skeletonUI" />;
+        } else if (visibleTiles.length > 0 && this.props.forceExpanded) {
             content = <div className="mx_RoomSublist_resizeBox mx_RoomSublist_resizeBox_forceExpanded">
                 <div className="mx_RoomSublist_tiles" ref={this.tilesRef}>
                     { visibleTiles }

From 0dc70042d6d6536c302409d2c35c2585ea1cb368 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 5 Aug 2022 13:01:47 +0100
Subject: [PATCH 38/81] Filter out spaces from the room list

---
 src/components/views/rooms/RoomList.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index 3062adc5d6a..a9273a06cd7 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -669,6 +669,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
                 is_dm: false,
                 is_invite: false,
                 is_tombstoned: false,
+                not_room_types: ["m.space"],
                 spaces: SpaceStore.instance.activeSpaceRoom ? [SpaceStore.instance.activeSpaceRoom.roomId] : undefined,
             },
         };

From c22aeb703b1588e1eddbc96bbeebd72c1004879f Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 5 Aug 2022 17:35:30 +0100
Subject: [PATCH 39/81] Use the new txn_id promises

---
 src/SlidingSyncManager.ts | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 4e6ddcf94f1..b73c1760b35 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -158,7 +158,7 @@ export class SlidingSyncManager {
     async ensureListRegistered(
         listIndex: number, updateArgs: PartialSlidingSyncRequest,
     ): Promise<MSC3575List> {
-        logger.debug("ensureListRegistered", listIndex, updateArgs);
+        logger.debug("ensureListRegistered:::", listIndex, updateArgs);
         await this.configurePromise;
         let list = this.slidingSync.getList(listIndex);
         if (!list) {
@@ -187,23 +187,14 @@ export class SlidingSyncManager {
             }
             list = updatedList;
         }
+
         // if we only have range changes then call a different function so we don't nuke the list from before
         if (updateArgs.ranges && Object.keys(updateArgs).length === 1) {
-            this.slidingSync.setListRanges(listIndex, updateArgs.ranges);
+            await this.slidingSync.setListRanges(listIndex, updateArgs.ranges);
         } else {
-            this.slidingSync.setList(listIndex, list);
+            await this.slidingSync.setList(listIndex, list);
         }
-
-        return new Promise((resolve) => {
-            const resolveOnSubscribed = (state: SlidingSyncState, resp: MSC3575SlidingSyncResponse, err: Error) => {
-                if (state === SlidingSyncState.Complete && resp.lists[listIndex]) { // we processed a /sync response
-                    this.slidingSync.off(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
-                    resolve(list);
-                }
-            };
-            // wait until the next sync before returning as RoomView may need to know the current state
-            this.slidingSync.on(SlidingSyncEvent.Lifecycle, resolveOnSubscribed);
-        });
+        return this.slidingSync.getList(listIndex);
     }
 
     async setRoomVisible(roomId: string, visible: boolean): Promise<string> {

From a81a6ea4e47d82382b511866e2736a61585f2a10 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 5 Aug 2022 17:45:18 +0100
Subject: [PATCH 40/81] Ensure we actually resolve list registrations

---
 src/SlidingSyncManager.ts | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index b73c1760b35..c8294a3ca35 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -188,11 +188,15 @@ export class SlidingSyncManager {
             list = updatedList;
         }
 
-        // if we only have range changes then call a different function so we don't nuke the list from before
-        if (updateArgs.ranges && Object.keys(updateArgs).length === 1) {
-            await this.slidingSync.setListRanges(listIndex, updateArgs.ranges);
-        } else {
-            await this.slidingSync.setList(listIndex, list);
+        try {
+            // if we only have range changes then call a different function so we don't nuke the list from before
+            if (updateArgs.ranges && Object.keys(updateArgs).length === 1) {
+                await this.slidingSync.setListRanges(listIndex, updateArgs.ranges);
+            } else {
+                await this.slidingSync.setList(listIndex, list);
+            }
+        } catch (err) {
+            logger.debug("ensureListRegistered: update failed txn_id=", err);
         }
         return this.slidingSync.getList(listIndex);
     }

From 34df9d6b6c264438fa073431ee8a81df458b3313 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 8 Aug 2022 12:22:27 +0100
Subject: [PATCH 41/81] Fix matrix-org/sliding-sync#30: don't show tombstoned
 search results

---
 src/hooks/useSlidingSyncRoomSearch.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/hooks/useSlidingSyncRoomSearch.ts b/src/hooks/useSlidingSyncRoomSearch.ts
index 9fd2304b708..42be40142af 100644
--- a/src/hooks/useSlidingSyncRoomSearch.ts
+++ b/src/hooks/useSlidingSyncRoomSearch.ts
@@ -52,6 +52,7 @@ export const useSlidingSyncRoomSearch = () => {
                 ranges: [[0, limit]],
                 filters: {
                     room_name_like: term,
+                    is_tombstoned: false,
                 },
             });
             const rooms = [];

From 2d1385ab20918518934071f00ab0ed21f9cbc371 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 8 Aug 2022 12:50:35 +0100
Subject: [PATCH 42/81] Remove unused imports

---
 src/SlidingSyncManager.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index c8294a3ca35..c92dbd43338 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -48,8 +48,8 @@ import { MatrixClient } from 'matrix-js-sdk/src/matrix';
 import { EventType } from 'matrix-js-sdk/src/@types/event';
 import {
     MSC3575Filter,
-    MSC3575List, MSC3575SlidingSyncResponse, SlidingSync,
-    SlidingSyncEvent, SlidingSyncState,
+    MSC3575List, SlidingSync,
+    SlidingSyncEvent,
 } from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";
 

From 0e1272c06e400c427a8039bdd1fea997e12e5d60 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 8 Aug 2022 18:18:43 +0100
Subject: [PATCH 43/81] Add SYNCV3_SECRET to proxy to ensure it starts up;
 correct aliases for SS test

---
 cypress/e2e/sliding-sync/sliding-sync.ts | 12 ++++++------
 cypress/plugins/sliding-sync/index.ts    |  4 ++++
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index 534b9ac0df5..82405e49aa9 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -34,7 +34,7 @@ describe("Sliding Sync", () => {
             cy.enableLabsFeature("feature_sliding_sync");
 
             cy.intercept("/config.json?cachebuster=*", req => {
-                req.continue(res => {
+                return req.continue(res => {
                     res.send(200, {
                         ...res.body,
                         sliding_sync_proxy_url: `http://localhost:${proxy.port}`,
@@ -42,16 +42,16 @@ describe("Sliding Sync", () => {
                 });
             });
 
-            cy.initTestUser(synapse, "Sloth").then(() =>
-                cy.window({ log: false }).then(() => {
+            cy.initTestUser(synapse, "Sloth").then(() => {
+                return cy.window({ log: false }).then(() => {
                     cy.createRoom({ name: "Test Room" }).as("roomId");
-                }),
-            );
+                });
+            });
         });
     });
 
     it("should correctly render expected messages", () => {
-        cy.get<string>("@room").then(roomId => cy.visit("/#/room/" + roomId));
+        cy.get<string>("@roomId").then(roomId => cy.visit("/#/room/" + roomId));
         cy.setSettingValue("layout", null, SettingLevel.DEVICE, Layout.IRC);
 
         // Wait until configuration is finished
diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index 47732aae5eb..906a3e1dd71 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -48,20 +48,24 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
 
     const postgresIp = await dockerIp({ containerId: postgresId });
     const synapseIp = await dockerIp({ containerId: synapse.synapseId });
+    console.log("postgres container up");
 
     await new Promise(resolve => setTimeout(resolve, 5000));
 
     const port = await getFreePort();
+    console.log("starting proxy container...");
     const containerId = await dockerRun({
         image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.2.0",
         containerName: "react-sdk-cypress-sliding-sync-proxy",
         params: [
             "--rm",
             "-p", `${port}:8008/tcp`,
+            "-e", "SYNCV3_SECRET=bwahahaha",
             "-e", `SYNCV3_SERVER=http://${synapseIp}:8008`,
             "-e", `SYNCV3_DB=user=postgres dbname=postgres password=${PG_PASSWORD} host=${postgresIp} sslmode=disable`,
         ],
     });
+    console.log("started!");
 
     const instance: ProxyInstance = { containerId, postgresId, port };
     instances.set(containerId, instance);

From 6dd3cd43eb92571d89ecf120d2d4d34819605f2b Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 10 Aug 2022 09:44:49 +0100
Subject: [PATCH 44/81] Add another basic sliding sync e2e test

---
 cypress/e2e/sliding-sync/sliding-sync.ts | 15 ++++++++-
 cypress/plugins/sliding-sync/index.ts    | 40 ++++++++++++++++++------
 2 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index 82405e49aa9..41bdb6b22ac 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -50,6 +50,12 @@ describe("Sliding Sync", () => {
         });
     });
 
+    afterEach(() => {
+        cy.get<SynapseInstance>("@synapse").then(cy.stopSynapse);
+        cy.get<ProxyInstance>("@proxy").then(cy.stopProxy);
+    });
+
+    // sanity check everything works
     it("should correctly render expected messages", () => {
         cy.get<string>("@roomId").then(roomId => cy.visit("/#/room/" + roomId));
         cy.setSettingValue("layout", null, SettingLevel.DEVICE, Layout.IRC);
@@ -62,7 +68,14 @@ describe("Sliding Sync", () => {
 
         // Click "expand" link button
         cy.get(".mx_GenericEventListSummary_toggle[aria-expanded=false]").click();
+    });
 
-        cy.pause();
+    it.only("should render rooms in reverse chronological order", () => {
+        // create rooms and check room names are correct
+        cy.createRoom({ name: "Apple" }).as("roomApple").then(()=>cy.contains(".mx_RoomSublist", "Apple"));
+        cy.createRoom({ name: "Pineapple" }).as("roomPineapple").then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
+        cy.createRoom({ name: "Orange" }).as("roomOrange").then(()=>cy.contains(".mx_RoomSublist", "Orange"));
+        // check the rooms are in the right order
+        cy.get(".mx_RoomTile").should('have.length', 4); // due to the Test Room in beforeEach
     });
 });
diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index 906a3e1dd71..f5dca703173 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -18,7 +18,7 @@ limitations under the License.
 
 import PluginEvents = Cypress.PluginEvents;
 import PluginConfigOptions = Cypress.PluginConfigOptions;
-import { dockerIp, dockerRun, dockerStop } from "../docker";
+import { dockerExec, dockerIp, dockerRun, dockerStop } from "../docker";
 import { getFreePort } from "../utils/port";
 import { SynapseInstance } from "../synapsedocker";
 
@@ -35,7 +35,7 @@ const instances = new Map<string, ProxyInstance>();
 const PG_PASSWORD = "p4S5w0rD";
 
 async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
-    console.log("Starting sliding sync proxy...");
+    console.log(new Date(),"Starting sliding sync proxy...");
 
     const postgresId = await dockerRun({
         image: "postgres",
@@ -48,14 +48,36 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
 
     const postgresIp = await dockerIp({ containerId: postgresId });
     const synapseIp = await dockerIp({ containerId: synapse.synapseId });
-    console.log("postgres container up");
-
-    await new Promise(resolve => setTimeout(resolve, 5000));
+    console.log(new Date(), "postgres container up");
+
+    const waitTimeMillis = 30000;
+    const startTime = new Date().getTime();
+    let lastErr: Error;
+    while ((new Date().getTime() - startTime) < waitTimeMillis) {
+        try {
+            await dockerExec({
+                containerId: postgresId,
+                params: [
+                    "pg_isready",
+                    "-U", "postgres",
+                ],
+            });
+            lastErr = null;
+            break;
+        } catch(err) {
+            console.log("pg_isready: failed");
+            lastErr = err;
+        }
+    }
+    if (lastErr) {
+        console.log("rethrowing");
+        throw lastErr;
+    }
 
     const port = await getFreePort();
-    console.log("starting proxy container...");
+    console.log(new Date(),"starting proxy container...");
     const containerId = await dockerRun({
-        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.2.0",
+        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.3.0",
         containerName: "react-sdk-cypress-sliding-sync-proxy",
         params: [
             "--rm",
@@ -65,7 +87,7 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
             "-e", `SYNCV3_DB=user=postgres dbname=postgres password=${PG_PASSWORD} host=${postgresIp} sslmode=disable`,
         ],
     });
-    console.log("started!");
+    console.log(new Date(),"started!");
 
     const instance: ProxyInstance = { containerId, postgresId, port };
     instances.set(containerId, instance);
@@ -82,7 +104,7 @@ async function proxyStop(instance: ProxyInstance): Promise<void> {
 
     instances.delete(instance.containerId);
 
-    console.log("Stopped sliding sync proxy.");
+    console.log(new Date(),"Stopped sliding sync proxy.");
     // cypress deliberately fails if you return 'undefined', so
     // return null to signal all is well, and we've handled the task.
     return null;

From b6ac97c74d0d62dadcff783349da1c53b0ac4292 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 11 Aug 2022 15:24:48 +0100
Subject: [PATCH 45/81] Unbreak netlify

---
 src/components/views/dialogs/spotlight/SpotlightDialog.tsx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
index 5df84a292a6..4ab1560d413 100644
--- a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
+++ b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
@@ -92,7 +92,6 @@ import { RoomResultContextMenus } from "./RoomResultContextMenus";
 import { RoomContextDetails } from "../../rooms/RoomContextDetails";
 import { TooltipOption } from "./TooltipOption";
 import { isLocalRoom } from "../../../../utils/localRoom/isLocalRoom";
-import { startDm } from "../../../../utils/dm/startDm";
 import { useSlidingSyncRoomSearch } from "../../../../hooks/useSlidingSyncRoomSearch";
 
 const MAX_RECENT_SEARCHES = 10;

From d9368d94dcf55c3fe8ad099be3839b4a112b1088 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 11 Aug 2022 16:12:14 +0100
Subject: [PATCH 46/81] Add more logging for debugging duplicate rooms

---
 src/components/views/rooms/RoomSublist.tsx | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index fdb78f6f08e..9b7f12d6d32 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -332,8 +332,13 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         }).sort((a, b) => {
             return a-b;
         });
+        const seenRoomIds = new Set<string>();
         const orderedRoomIds = orderedRoomIndexes.map((i) => {
             const rid = roomIndexToRoomId[i];
+            if (seenRoomIds.has(rid)) {
+                logger.error("room " + rid + " already has an index position: duplicate room!");
+            }
+            seenRoomIds.add(rid);
             if (!rid) {
                 throw new Error("index " + i + " has no room ID: Map => " + JSON.stringify(roomIndexToRoomId));
             }
@@ -341,7 +346,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         });
         logger.debug(
             "onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:",
-            orderedRoomIds.length < 10 ? orderedRoomIds : orderedRoomIds.length,
+            orderedRoomIds.length < 30 ? orderedRoomIds : orderedRoomIds.length,
         );
         // now set the rooms
         this.setState({

From cda609dc58e452297a0d04f134052bea40c78e7d Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 11 Aug 2022 18:20:41 +0100
Subject: [PATCH 47/81] If sliding sync is enabled, always use the rooms result
 even if it's empty

---
 src/components/views/dialogs/spotlight/SpotlightDialog.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
index 4ab1560d413..b0a6b125eaf 100644
--- a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
+++ b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
@@ -356,7 +356,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
         () => {
             const userResults = [];
             let roomResults;
-            if (isSlidingSyncEnabled && slidingSyncRooms.length > 0) {
+            if (isSlidingSyncEnabled) {
                 // use the rooms sliding sync returned as the server has already worked it out for us
                 roomResults = slidingSyncRooms.map(toRoomResult);
             } else {

From d44b31de15562d473db8df1f8d466a155ff6f42b Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 12 Aug 2022 13:59:54 +0100
Subject: [PATCH 48/81] Drop-in copy of RoomListStore for sliding sync

---
 src/stores/room-list/RoomListStore.ts        |   8 +-
 src/stores/room-list/SlidingRoomListStore.ts | 598 +++++++++++++++++++
 src/stores/room-list/SpaceWatcher.ts         |   4 +-
 3 files changed, 607 insertions(+), 3 deletions(-)
 create mode 100644 src/stores/room-list/SlidingRoomListStore.ts

diff --git a/src/stores/room-list/RoomListStore.ts b/src/stores/room-list/RoomListStore.ts
index d518f43d9e2..f4b6cc4629c 100644
--- a/src/stores/room-list/RoomListStore.ts
+++ b/src/stores/room-list/RoomListStore.ts
@@ -38,6 +38,7 @@ import { VisibilityProvider } from "./filters/VisibilityProvider";
 import { SpaceWatcher } from "./SpaceWatcher";
 import { IRoomTimelineActionPayload } from "../../actions/MatrixActionCreators";
 import { RoomListStore as Interface, RoomListStoreEvent } from "./Interface";
+import { SlidingRoomListStoreClass } from "./SlidingRoomListStore";
 
 interface IState {
     // state is tracked in underlying classes
@@ -609,7 +610,12 @@ export default class RoomListStore {
 
     public static get instance(): Interface {
         if (!RoomListStore.internalInstance) {
-            RoomListStore.internalInstance = new RoomListStoreClass();
+            if (SettingsStore.getValue("feature_sliding_sync")) {
+                logger.info("using SlidingRoomListStoreClass");
+                RoomListStore.internalInstance = new SlidingRoomListStoreClass();
+            } else {
+                RoomListStore.internalInstance = new RoomListStoreClass();
+            }
         }
 
         return RoomListStore.internalInstance;
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
new file mode 100644
index 00000000000..a4ba1569d68
--- /dev/null
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -0,0 +1,598 @@
+/*
+Copyright 2018 - 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MatrixClient } from "matrix-js-sdk/src/client";
+import { Room } from "matrix-js-sdk/src/models/room";
+import { isNullOrUndefined } from "matrix-js-sdk/src/utils";
+import { logger } from "matrix-js-sdk/src/logger";
+import { EventType } from "matrix-js-sdk/src/@types/event";
+
+import SettingsStore from "../../settings/SettingsStore";
+import { DefaultTagID, OrderedDefaultTagIDs, RoomUpdateCause, TagID } from "./models";
+import { IListOrderingMap, ITagMap, ITagSortingMap, ListAlgorithm, SortAlgorithm } from "./algorithms/models";
+import { ActionPayload } from "../../dispatcher/payloads";
+import defaultDispatcher from "../../dispatcher/dispatcher";
+import { readReceiptChangeIsFor } from "../../utils/read-receipts";
+import { FILTER_CHANGED, IFilterCondition } from "./filters/IFilterCondition";
+import { RoomViewStore } from "../RoomViewStore";
+import { Algorithm, LIST_UPDATED_EVENT } from "./algorithms/Algorithm";
+import { EffectiveMembership, getEffectiveMembership } from "../../utils/membership";
+import RoomListLayoutStore from "./RoomListLayoutStore";
+import { MarkedExecution } from "../../utils/MarkedExecution";
+import { AsyncStoreWithClient } from "../AsyncStoreWithClient";
+import { RoomNotificationStateStore } from "../notifications/RoomNotificationStateStore";
+import { VisibilityProvider } from "./filters/VisibilityProvider";
+import { SpaceWatcher } from "./SpaceWatcher";
+import { IRoomTimelineActionPayload } from "../../actions/MatrixActionCreators";
+import { RoomListStore as Interface, RoomListStoreEvent } from "./Interface";
+
+interface IState {
+    // state is tracked in underlying classes
+}
+
+export const LISTS_UPDATE_EVENT = RoomListStoreEvent.ListsUpdate;
+
+export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> implements Interface {
+    /**
+     * Set to true if you're running tests on the store. Should not be touched in
+     * any other environment.
+     */
+    public static TEST_MODE = false;
+
+    private initialListsGenerated = false;
+    private algorithm = new Algorithm();
+    private prefilterConditions: IFilterCondition[] = [];
+    private updateFn = new MarkedExecution(() => {
+        for (const tagId of Object.keys(this.orderedLists)) {
+            RoomNotificationStateStore.instance.getListState(tagId).setRooms(this.orderedLists[tagId]);
+        }
+        this.emit(LISTS_UPDATE_EVENT);
+    });
+
+    constructor() {
+        super(defaultDispatcher);
+        this.setMaxListeners(20); // RoomList + LeftPanel + 8xRoomSubList + spares
+        this.algorithm.start();
+    }
+
+    private setupWatchers() {
+        // TODO: Maybe destroy this if this class supports destruction
+        new SpaceWatcher(this);
+    }
+
+    public get orderedLists(): ITagMap {
+        if (!this.algorithm) return {}; // No tags yet.
+        return this.algorithm.getOrderedRooms();
+    }
+
+    // Intended for test usage
+    public async resetStore() {
+        await this.reset();
+        this.prefilterConditions = [];
+        this.initialListsGenerated = false;
+
+        this.algorithm.off(LIST_UPDATED_EVENT, this.onAlgorithmListUpdated);
+        this.algorithm.off(FILTER_CHANGED, this.onAlgorithmListUpdated);
+        this.algorithm.stop();
+        this.algorithm = new Algorithm();
+        this.algorithm.on(LIST_UPDATED_EVENT, this.onAlgorithmListUpdated);
+        this.algorithm.on(FILTER_CHANGED, this.onAlgorithmListUpdated);
+
+        // Reset state without causing updates as the client will have been destroyed
+        // and downstream code will throw NPE errors.
+        await this.reset(null, true);
+    }
+
+    // Public for test usage. Do not call this.
+    public async makeReady(forcedClient?: MatrixClient) {
+        if (forcedClient) {
+            this.readyStore.useUnitTestClient(forcedClient);
+        }
+
+        RoomViewStore.instance.addListener(() => this.handleRVSUpdate({}));
+        this.algorithm.on(LIST_UPDATED_EVENT, this.onAlgorithmListUpdated);
+        this.algorithm.on(FILTER_CHANGED, this.onAlgorithmFilterUpdated);
+        this.setupWatchers();
+
+        // Update any settings here, as some may have happened before we were logically ready.
+        logger.log("Regenerating room lists: Startup");
+        this.updateAlgorithmInstances();
+        this.regenerateAllLists({ trigger: false });
+        this.handleRVSUpdate({ trigger: false }); // fake an RVS update to adjust sticky room, if needed
+
+        this.updateFn.mark(); // we almost certainly want to trigger an update.
+        this.updateFn.trigger();
+    }
+
+    /**
+     * Handles suspected RoomViewStore changes.
+     * @param trigger Set to false to prevent a list update from being sent. Should only
+     * be used if the calling code will manually trigger the update.
+     */
+    private handleRVSUpdate({ trigger = true }) {
+        if (!this.matrixClient) return; // We assume there won't be RVS updates without a client
+        if (SettingsStore.getValue("feature_sliding_sync")) {
+            return; // we don't need any of this in sliding sync mode.
+        }
+
+        const activeRoomId = RoomViewStore.instance.getRoomId();
+        if (!activeRoomId && this.algorithm.stickyRoom) {
+            this.algorithm.setStickyRoom(null);
+        } else if (activeRoomId) {
+            const activeRoom = this.matrixClient.getRoom(activeRoomId);
+            if (!activeRoom) {
+                logger.warn(`${activeRoomId} is current in RVS but missing from client - clearing sticky room`);
+                this.algorithm.setStickyRoom(null);
+            } else if (activeRoom !== this.algorithm.stickyRoom) {
+                this.algorithm.setStickyRoom(activeRoom);
+            }
+        }
+
+        if (trigger) this.updateFn.trigger();
+    }
+
+    protected async onReady(): Promise<any> {
+        await this.makeReady();
+    }
+
+    protected async onNotReady(): Promise<any> {
+        await this.resetStore();
+    }
+
+    protected async onAction(payload: ActionPayload) {
+        // If we're not remotely ready, don't even bother scheduling the dispatch handling.
+        // This is repeated in the handler just in case things change between a decision here and
+        // when the timer fires.
+        const logicallyReady = this.matrixClient && this.initialListsGenerated;
+        if (!logicallyReady) return;
+
+        // We do this to intentionally break out of the current event loop task, allowing
+        // us to instead wait for a more convenient time to run our updates.
+        setImmediate(() => this.onDispatchAsync(payload));
+    }
+
+    protected async onDispatchAsync(payload: ActionPayload) {
+        // Everything here requires a MatrixClient or some sort of logical readiness.
+        const logicallyReady = this.matrixClient && this.initialListsGenerated;
+        if (!logicallyReady) return;
+        if (SettingsStore.getValue("feature_sliding_sync")) {
+            return; // we don't need any of this in sliding sync mode.
+        }
+
+        if (!this.algorithm) {
+            // This shouldn't happen because `initialListsGenerated` implies we have an algorithm.
+            throw new Error("Room list store has no algorithm to process dispatcher update with");
+        }
+
+        if (payload.action === 'MatrixActions.Room.receipt') {
+            // First see if the receipt event is for our own user. If it was, trigger
+            // a room update (we probably read the room on a different device).
+            if (readReceiptChangeIsFor(payload.event, this.matrixClient)) {
+                const room = payload.room;
+                if (!room) {
+                    logger.warn(`Own read receipt was in unknown room ${room.roomId}`);
+                    return;
+                }
+                await this.handleRoomUpdate(room, RoomUpdateCause.ReadReceipt);
+                this.updateFn.trigger();
+                return;
+            }
+        } else if (payload.action === 'MatrixActions.Room.tags') {
+            const roomPayload = (<any>payload); // TODO: Type out the dispatcher types
+            await this.handleRoomUpdate(roomPayload.room, RoomUpdateCause.PossibleTagChange);
+            this.updateFn.trigger();
+        } else if (payload.action === 'MatrixActions.Room.timeline') {
+            const eventPayload = <IRoomTimelineActionPayload>payload;
+
+            // Ignore non-live events (backfill) and notification timeline set events (without a room)
+            if (!eventPayload.isLiveEvent ||
+                !eventPayload.isLiveUnfilteredRoomTimelineEvent ||
+                !eventPayload.room
+            ) {
+                return;
+            }
+
+            const roomId = eventPayload.event.getRoomId();
+            const room = this.matrixClient.getRoom(roomId);
+            const tryUpdate = async (updatedRoom: Room) => {
+                if (eventPayload.event.getType() === EventType.RoomTombstone &&
+                    eventPayload.event.getStateKey() === ''
+                ) {
+                    const newRoom = this.matrixClient.getRoom(eventPayload.event.getContent()['replacement_room']);
+                    if (newRoom) {
+                        // If we have the new room, then the new room check will have seen the predecessor
+                        // and did the required updates, so do nothing here.
+                        return;
+                    }
+                }
+                await this.handleRoomUpdate(updatedRoom, RoomUpdateCause.Timeline);
+                this.updateFn.trigger();
+            };
+            if (!room) {
+                logger.warn(`Live timeline event ${eventPayload.event.getId()} received without associated room`);
+                logger.warn(`Queuing failed room update for retry as a result.`);
+                setTimeout(async () => {
+                    const updatedRoom = this.matrixClient.getRoom(roomId);
+                    await tryUpdate(updatedRoom);
+                }, 100); // 100ms should be enough for the room to show up
+                return;
+            } else {
+                await tryUpdate(room);
+            }
+        } else if (payload.action === 'MatrixActions.Event.decrypted') {
+            const eventPayload = (<any>payload); // TODO: Type out the dispatcher types
+            const roomId = eventPayload.event.getRoomId();
+            if (!roomId) {
+                return;
+            }
+            const room = this.matrixClient.getRoom(roomId);
+            if (!room) {
+                logger.warn(`Event ${eventPayload.event.getId()} was decrypted in an unknown room ${roomId}`);
+                return;
+            }
+            await this.handleRoomUpdate(room, RoomUpdateCause.Timeline);
+            this.updateFn.trigger();
+        } else if (payload.action === 'MatrixActions.accountData' && payload.event_type === EventType.Direct) {
+            const eventPayload = (<any>payload); // TODO: Type out the dispatcher types
+            const dmMap = eventPayload.event.getContent();
+            for (const userId of Object.keys(dmMap)) {
+                const roomIds = dmMap[userId];
+                for (const roomId of roomIds) {
+                    const room = this.matrixClient.getRoom(roomId);
+                    if (!room) {
+                        logger.warn(`${roomId} was found in DMs but the room is not in the store`);
+                        continue;
+                    }
+
+                    // We expect this RoomUpdateCause to no-op if there's no change, and we don't expect
+                    // the user to have hundreds of rooms to update in one event. As such, we just hammer
+                    // away at updates until the problem is solved. If we were expecting more than a couple
+                    // of rooms to be updated at once, we would consider batching the rooms up.
+                    await this.handleRoomUpdate(room, RoomUpdateCause.PossibleTagChange);
+                }
+            }
+            this.updateFn.trigger();
+        } else if (payload.action === 'MatrixActions.Room.myMembership') {
+            const membershipPayload = (<any>payload); // TODO: Type out the dispatcher types
+            const oldMembership = getEffectiveMembership(membershipPayload.oldMembership);
+            const newMembership = getEffectiveMembership(membershipPayload.membership);
+            if (oldMembership !== EffectiveMembership.Join && newMembership === EffectiveMembership.Join) {
+                // If we're joining an upgraded room, we'll want to make sure we don't proliferate
+                // the dead room in the list.
+                const createEvent = membershipPayload.room.currentState.getStateEvents(EventType.RoomCreate, "");
+                if (createEvent && createEvent.getContent()['predecessor']) {
+                    const prevRoom = this.matrixClient.getRoom(createEvent.getContent()['predecessor']['room_id']);
+                    if (prevRoom) {
+                        const isSticky = this.algorithm.stickyRoom === prevRoom;
+                        if (isSticky) {
+                            this.algorithm.setStickyRoom(null);
+                        }
+
+                        // Note: we hit the algorithm instead of our handleRoomUpdate() function to
+                        // avoid redundant updates.
+                        this.algorithm.handleRoomUpdate(prevRoom, RoomUpdateCause.RoomRemoved);
+                    }
+                }
+
+                await this.handleRoomUpdate(membershipPayload.room, RoomUpdateCause.NewRoom);
+                this.updateFn.trigger();
+                return;
+            }
+
+            if (oldMembership !== EffectiveMembership.Invite && newMembership === EffectiveMembership.Invite) {
+                await this.handleRoomUpdate(membershipPayload.room, RoomUpdateCause.NewRoom);
+                this.updateFn.trigger();
+                return;
+            }
+
+            // If it's not a join, it's transitioning into a different list (possibly historical)
+            if (oldMembership !== newMembership) {
+                await this.handleRoomUpdate(membershipPayload.room, RoomUpdateCause.PossibleTagChange);
+                this.updateFn.trigger();
+                return;
+            }
+        }
+    }
+
+    private async handleRoomUpdate(room: Room, cause: RoomUpdateCause): Promise<any> {
+        if (cause === RoomUpdateCause.NewRoom && room.getMyMembership() === "invite") {
+            // Let the visibility provider know that there is a new invited room. It would be nice
+            // if this could just be an event that things listen for but the point of this is that
+            // we delay doing anything about this room until the VoipUserMapper had had a chance
+            // to do the things it needs to do to decide if we should show this room or not, so
+            // an even wouldn't et us do that.
+            await VisibilityProvider.instance.onNewInvitedRoom(room);
+        }
+
+        if (!VisibilityProvider.instance.isRoomVisible(room)) {
+            return; // don't do anything on rooms that aren't visible
+        }
+
+        if ((cause === RoomUpdateCause.NewRoom || cause === RoomUpdateCause.PossibleTagChange) &&
+            !this.prefilterConditions.every(c => c.isVisible(room))
+        ) {
+            return; // don't do anything on new/moved rooms which ought not to be shown
+        }
+
+        const shouldUpdate = this.algorithm.handleRoomUpdate(room, cause);
+        if (shouldUpdate) {
+            this.updateFn.mark();
+        }
+    }
+
+    private async recalculatePrefiltering() {
+        if (!this.algorithm) return;
+        if (!this.algorithm.hasTagSortingMap) return; // we're still loading
+
+        // Inhibit updates because we're about to lie heavily to the algorithm
+        this.algorithm.updatesInhibited = true;
+
+        // Figure out which rooms are about to be valid, and the state of affairs
+        const rooms = this.getPlausibleRooms();
+        const currentSticky = this.algorithm.stickyRoom;
+        const stickyIsStillPresent = currentSticky && rooms.includes(currentSticky);
+
+        // Reset the sticky room before resetting the known rooms so the algorithm
+        // doesn't freak out.
+        this.algorithm.setStickyRoom(null);
+        this.algorithm.setKnownRooms(rooms);
+
+        // Set the sticky room back, if needed, now that we have updated the store.
+        // This will use relative stickyness to the new room set.
+        if (stickyIsStillPresent) {
+            this.algorithm.setStickyRoom(currentSticky);
+        }
+
+        // Finally, mark an update and resume updates from the algorithm
+        this.updateFn.mark();
+        this.algorithm.updatesInhibited = false;
+    }
+
+    public setTagSorting(tagId: TagID, sort: SortAlgorithm) {
+        this.setAndPersistTagSorting(tagId, sort);
+        this.updateFn.trigger();
+    }
+
+    private setAndPersistTagSorting(tagId: TagID, sort: SortAlgorithm) {
+        this.algorithm.setTagSorting(tagId, sort);
+        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
+        localStorage.setItem(`mx_tagSort_${tagId}`, sort);
+    }
+
+    public getTagSorting(tagId: TagID): SortAlgorithm {
+        return this.algorithm.getTagSorting(tagId);
+    }
+
+    // noinspection JSMethodCanBeStatic
+    private getStoredTagSorting(tagId: TagID): SortAlgorithm {
+        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
+        return <SortAlgorithm>localStorage.getItem(`mx_tagSort_${tagId}`);
+    }
+
+    // logic must match calculateListOrder
+    private calculateTagSorting(tagId: TagID): SortAlgorithm {
+        const isDefaultRecent = tagId === DefaultTagID.Invite || tagId === DefaultTagID.DM;
+        const defaultSort = isDefaultRecent ? SortAlgorithm.Recent : SortAlgorithm.Alphabetic;
+        const settingAlphabetical = SettingsStore.getValue("RoomList.orderAlphabetically", null, true);
+        const definedSort = this.getTagSorting(tagId);
+        const storedSort = this.getStoredTagSorting(tagId);
+
+        // We use the following order to determine which of the 4 flags to use:
+        // Stored > Settings > Defined > Default
+
+        let tagSort = defaultSort;
+        if (storedSort) {
+            tagSort = storedSort;
+        } else if (!isNullOrUndefined(settingAlphabetical)) {
+            tagSort = settingAlphabetical ? SortAlgorithm.Alphabetic : SortAlgorithm.Recent;
+        } else if (definedSort) {
+            tagSort = definedSort;
+        } // else default (already set)
+
+        return tagSort;
+    }
+
+    public setListOrder(tagId: TagID, order: ListAlgorithm) {
+        this.setAndPersistListOrder(tagId, order);
+        this.updateFn.trigger();
+    }
+
+    private setAndPersistListOrder(tagId: TagID, order: ListAlgorithm) {
+        this.algorithm.setListOrdering(tagId, order);
+        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
+        localStorage.setItem(`mx_listOrder_${tagId}`, order);
+    }
+
+    public getListOrder(tagId: TagID): ListAlgorithm {
+        return this.algorithm.getListOrdering(tagId);
+    }
+
+    // noinspection JSMethodCanBeStatic
+    private getStoredListOrder(tagId: TagID): ListAlgorithm {
+        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
+        return <ListAlgorithm>localStorage.getItem(`mx_listOrder_${tagId}`);
+    }
+
+    // logic must match calculateTagSorting
+    private calculateListOrder(tagId: TagID): ListAlgorithm {
+        const defaultOrder = ListAlgorithm.Natural;
+        const settingImportance = SettingsStore.getValue("RoomList.orderByImportance", null, true);
+        const definedOrder = this.getListOrder(tagId);
+        const storedOrder = this.getStoredListOrder(tagId);
+
+        // We use the following order to determine which of the 4 flags to use:
+        // Stored > Settings > Defined > Default
+
+        let listOrder = defaultOrder;
+        if (storedOrder) {
+            listOrder = storedOrder;
+        } else if (!isNullOrUndefined(settingImportance)) {
+            listOrder = settingImportance ? ListAlgorithm.Importance : ListAlgorithm.Natural;
+        } else if (definedOrder) {
+            listOrder = definedOrder;
+        } // else default (already set)
+
+        return listOrder;
+    }
+
+    private updateAlgorithmInstances() {
+        // We'll require an update, so mark for one. Marking now also prevents the calls
+        // to setTagSorting and setListOrder from causing triggers.
+        this.updateFn.mark();
+
+        for (const tag of Object.keys(this.orderedLists)) {
+            const definedSort = this.getTagSorting(tag);
+            const definedOrder = this.getListOrder(tag);
+
+            const tagSort = this.calculateTagSorting(tag);
+            const listOrder = this.calculateListOrder(tag);
+
+            if (tagSort !== definedSort) {
+                this.setAndPersistTagSorting(tag, tagSort);
+            }
+            if (listOrder !== definedOrder) {
+                this.setAndPersistListOrder(tag, listOrder);
+            }
+        }
+    }
+
+    private onAlgorithmListUpdated = (forceUpdate: boolean) => {
+        this.updateFn.mark();
+        if (forceUpdate) this.updateFn.trigger();
+    };
+
+    private onAlgorithmFilterUpdated = () => {
+        // The filter can happen off-cycle, so trigger an update. The filter will have
+        // already caused a mark.
+        this.updateFn.trigger();
+    };
+
+    private onPrefilterUpdated = async () => {
+        await this.recalculatePrefiltering();
+        this.updateFn.trigger();
+    };
+
+    private getPlausibleRooms(): Room[] {
+        if (!this.matrixClient) return [];
+
+        let rooms = this.matrixClient.getVisibleRooms().filter(r => VisibilityProvider.instance.isRoomVisible(r));
+
+        if (this.prefilterConditions.length > 0) {
+            rooms = rooms.filter(r => {
+                for (const filter of this.prefilterConditions) {
+                    if (!filter.isVisible(r)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+
+        return rooms;
+    }
+
+    /**
+     * Regenerates the room whole room list, discarding any previous results.
+     *
+     * Note: This is only exposed externally for the tests. Do not call this from within
+     * the app.
+     * @param trigger Set to false to prevent a list update from being sent. Should only
+     * be used if the calling code will manually trigger the update.
+     */
+    public regenerateAllLists({ trigger = true }) {
+        logger.warn("Regenerating all room lists");
+
+        const rooms = this.getPlausibleRooms();
+
+        const sorts: ITagSortingMap = {};
+        const orders: IListOrderingMap = {};
+        const allTags = [...OrderedDefaultTagIDs];
+        for (const tagId of allTags) {
+            sorts[tagId] = this.calculateTagSorting(tagId);
+            orders[tagId] = this.calculateListOrder(tagId);
+
+            RoomListLayoutStore.instance.ensureLayoutExists(tagId);
+        }
+
+        this.algorithm.populateTags(sorts, orders);
+        this.algorithm.setKnownRooms(rooms);
+
+        this.initialListsGenerated = true;
+
+        if (trigger) this.updateFn.trigger();
+    }
+
+    /**
+     * Adds a filter condition to the room list store. Filters may be applied async,
+     * and thus might not cause an update to the store immediately.
+     * @param {IFilterCondition} filter The filter condition to add.
+     */
+    public async addFilter(filter: IFilterCondition): Promise<void> {
+        let promise = Promise.resolve();
+        filter.on(FILTER_CHANGED, this.onPrefilterUpdated);
+        this.prefilterConditions.push(filter);
+        promise = this.recalculatePrefiltering();
+        promise.then(() => this.updateFn.trigger());
+    }
+
+    /**
+     * Removes a filter condition from the room list store. If the filter was
+     * not previously added to the room list store, this will no-op. The effects
+     * of removing a filter may be applied async and therefore might not cause
+     * an update right away.
+     * @param {IFilterCondition} filter The filter condition to remove.
+     */
+    public removeFilter(filter: IFilterCondition): void {
+        let promise = Promise.resolve();
+        let removed = false;
+        const idx = this.prefilterConditions.indexOf(filter);
+        if (idx >= 0) {
+            filter.off(FILTER_CHANGED, this.onPrefilterUpdated);
+            this.prefilterConditions.splice(idx, 1);
+            promise = this.recalculatePrefiltering();
+            removed = true;
+        }
+
+        if (removed) {
+            promise.then(() => this.updateFn.trigger());
+        }
+    }
+
+    /**
+     * Gets the tags for a room identified by the store. The returned set
+     * should never be empty, and will contain DefaultTagID.Untagged if
+     * the store is not aware of any tags.
+     * @param room The room to get the tags for.
+     * @returns The tags for the room.
+     */
+    public getTagsForRoom(room: Room): TagID[] {
+        const algorithmTags = this.algorithm.getTagsForRoom(room);
+        if (!algorithmTags) return [DefaultTagID.Untagged];
+        return algorithmTags;
+    }
+
+    /**
+     * Manually update a room with a given cause. This should only be used if the
+     * room list store would otherwise be incapable of doing the update itself. Note
+     * that this may race with the room list's regular operation.
+     * @param {Room} room The room to update.
+     * @param {RoomUpdateCause} cause The cause to update for.
+     */
+    public async manualRoomUpdate(room: Room, cause: RoomUpdateCause) {
+        await this.handleRoomUpdate(room, cause);
+        this.updateFn.trigger();
+    }
+}
diff --git a/src/stores/room-list/SpaceWatcher.ts b/src/stores/room-list/SpaceWatcher.ts
index af46a921cb8..31513b3de2b 100644
--- a/src/stores/room-list/SpaceWatcher.ts
+++ b/src/stores/room-list/SpaceWatcher.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { RoomListStoreClass } from "./RoomListStore";
+import { RoomListStore as Interface } from "./Interface";
 import { SpaceFilterCondition } from "./filters/SpaceFilterCondition";
 import SpaceStore from "../spaces/SpaceStore";
 import { MetaSpace, SpaceKey, UPDATE_HOME_BEHAVIOUR, UPDATE_SELECTED_SPACE } from "../spaces";
@@ -28,7 +28,7 @@ export class SpaceWatcher {
     private activeSpace: SpaceKey = SpaceStore.instance.activeSpace;
     private allRoomsInHome: boolean = SpaceStore.instance.allRoomsInHome;
 
-    constructor(private store: RoomListStoreClass) {
+    constructor(private store: Interface) {
         if (SpaceWatcher.needsFilter(this.activeSpace, this.allRoomsInHome)) {
             this.updateFilter();
             store.addFilter(this.filter);

From 4a6579f60268f31a7a5998b4a63513721244a63f Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 12 Aug 2022 15:23:54 +0100
Subject: [PATCH 49/81] Remove conditionals from RoomListStore - we have
 SlidingRoomListStore now

---
 src/stores/room-list/RoomListStore.ts        |   6 -
 src/stores/room-list/SlidingRoomListStore.ts | 159 -------------------
 2 files changed, 165 deletions(-)

diff --git a/src/stores/room-list/RoomListStore.ts b/src/stores/room-list/RoomListStore.ts
index f4b6cc4629c..ecd75cfb28d 100644
--- a/src/stores/room-list/RoomListStore.ts
+++ b/src/stores/room-list/RoomListStore.ts
@@ -125,9 +125,6 @@ export class RoomListStoreClass extends AsyncStoreWithClient<IState> implements
      */
     private handleRVSUpdate({ trigger = true }) {
         if (!this.matrixClient) return; // We assume there won't be RVS updates without a client
-        if (SettingsStore.getValue("feature_sliding_sync")) {
-            return; // we don't need any of this in sliding sync mode.
-        }
 
         const activeRoomId = RoomViewStore.instance.getRoomId();
         if (!activeRoomId && this.algorithm.stickyRoom) {
@@ -176,9 +173,6 @@ export class RoomListStoreClass extends AsyncStoreWithClient<IState> implements
         // Everything here requires a MatrixClient or some sort of logical readiness.
         const logicallyReady = this.matrixClient && this.initialListsGenerated;
         if (!logicallyReady) return;
-        if (SettingsStore.getValue("feature_sliding_sync")) {
-            return; // we don't need any of this in sliding sync mode.
-        }
 
         if (!this.algorithm) {
             // This shouldn't happen because `initialListsGenerated` implies we have an algorithm.
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index a4ba1569d68..91a19808107 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -123,25 +123,6 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
      * be used if the calling code will manually trigger the update.
      */
     private handleRVSUpdate({ trigger = true }) {
-        if (!this.matrixClient) return; // We assume there won't be RVS updates without a client
-        if (SettingsStore.getValue("feature_sliding_sync")) {
-            return; // we don't need any of this in sliding sync mode.
-        }
-
-        const activeRoomId = RoomViewStore.instance.getRoomId();
-        if (!activeRoomId && this.algorithm.stickyRoom) {
-            this.algorithm.setStickyRoom(null);
-        } else if (activeRoomId) {
-            const activeRoom = this.matrixClient.getRoom(activeRoomId);
-            if (!activeRoom) {
-                logger.warn(`${activeRoomId} is current in RVS but missing from client - clearing sticky room`);
-                this.algorithm.setStickyRoom(null);
-            } else if (activeRoom !== this.algorithm.stickyRoom) {
-                this.algorithm.setStickyRoom(activeRoom);
-            }
-        }
-
-        if (trigger) this.updateFn.trigger();
     }
 
     protected async onReady(): Promise<any> {
@@ -165,146 +146,6 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     protected async onDispatchAsync(payload: ActionPayload) {
-        // Everything here requires a MatrixClient or some sort of logical readiness.
-        const logicallyReady = this.matrixClient && this.initialListsGenerated;
-        if (!logicallyReady) return;
-        if (SettingsStore.getValue("feature_sliding_sync")) {
-            return; // we don't need any of this in sliding sync mode.
-        }
-
-        if (!this.algorithm) {
-            // This shouldn't happen because `initialListsGenerated` implies we have an algorithm.
-            throw new Error("Room list store has no algorithm to process dispatcher update with");
-        }
-
-        if (payload.action === 'MatrixActions.Room.receipt') {
-            // First see if the receipt event is for our own user. If it was, trigger
-            // a room update (we probably read the room on a different device).
-            if (readReceiptChangeIsFor(payload.event, this.matrixClient)) {
-                const room = payload.room;
-                if (!room) {
-                    logger.warn(`Own read receipt was in unknown room ${room.roomId}`);
-                    return;
-                }
-                await this.handleRoomUpdate(room, RoomUpdateCause.ReadReceipt);
-                this.updateFn.trigger();
-                return;
-            }
-        } else if (payload.action === 'MatrixActions.Room.tags') {
-            const roomPayload = (<any>payload); // TODO: Type out the dispatcher types
-            await this.handleRoomUpdate(roomPayload.room, RoomUpdateCause.PossibleTagChange);
-            this.updateFn.trigger();
-        } else if (payload.action === 'MatrixActions.Room.timeline') {
-            const eventPayload = <IRoomTimelineActionPayload>payload;
-
-            // Ignore non-live events (backfill) and notification timeline set events (without a room)
-            if (!eventPayload.isLiveEvent ||
-                !eventPayload.isLiveUnfilteredRoomTimelineEvent ||
-                !eventPayload.room
-            ) {
-                return;
-            }
-
-            const roomId = eventPayload.event.getRoomId();
-            const room = this.matrixClient.getRoom(roomId);
-            const tryUpdate = async (updatedRoom: Room) => {
-                if (eventPayload.event.getType() === EventType.RoomTombstone &&
-                    eventPayload.event.getStateKey() === ''
-                ) {
-                    const newRoom = this.matrixClient.getRoom(eventPayload.event.getContent()['replacement_room']);
-                    if (newRoom) {
-                        // If we have the new room, then the new room check will have seen the predecessor
-                        // and did the required updates, so do nothing here.
-                        return;
-                    }
-                }
-                await this.handleRoomUpdate(updatedRoom, RoomUpdateCause.Timeline);
-                this.updateFn.trigger();
-            };
-            if (!room) {
-                logger.warn(`Live timeline event ${eventPayload.event.getId()} received without associated room`);
-                logger.warn(`Queuing failed room update for retry as a result.`);
-                setTimeout(async () => {
-                    const updatedRoom = this.matrixClient.getRoom(roomId);
-                    await tryUpdate(updatedRoom);
-                }, 100); // 100ms should be enough for the room to show up
-                return;
-            } else {
-                await tryUpdate(room);
-            }
-        } else if (payload.action === 'MatrixActions.Event.decrypted') {
-            const eventPayload = (<any>payload); // TODO: Type out the dispatcher types
-            const roomId = eventPayload.event.getRoomId();
-            if (!roomId) {
-                return;
-            }
-            const room = this.matrixClient.getRoom(roomId);
-            if (!room) {
-                logger.warn(`Event ${eventPayload.event.getId()} was decrypted in an unknown room ${roomId}`);
-                return;
-            }
-            await this.handleRoomUpdate(room, RoomUpdateCause.Timeline);
-            this.updateFn.trigger();
-        } else if (payload.action === 'MatrixActions.accountData' && payload.event_type === EventType.Direct) {
-            const eventPayload = (<any>payload); // TODO: Type out the dispatcher types
-            const dmMap = eventPayload.event.getContent();
-            for (const userId of Object.keys(dmMap)) {
-                const roomIds = dmMap[userId];
-                for (const roomId of roomIds) {
-                    const room = this.matrixClient.getRoom(roomId);
-                    if (!room) {
-                        logger.warn(`${roomId} was found in DMs but the room is not in the store`);
-                        continue;
-                    }
-
-                    // We expect this RoomUpdateCause to no-op if there's no change, and we don't expect
-                    // the user to have hundreds of rooms to update in one event. As such, we just hammer
-                    // away at updates until the problem is solved. If we were expecting more than a couple
-                    // of rooms to be updated at once, we would consider batching the rooms up.
-                    await this.handleRoomUpdate(room, RoomUpdateCause.PossibleTagChange);
-                }
-            }
-            this.updateFn.trigger();
-        } else if (payload.action === 'MatrixActions.Room.myMembership') {
-            const membershipPayload = (<any>payload); // TODO: Type out the dispatcher types
-            const oldMembership = getEffectiveMembership(membershipPayload.oldMembership);
-            const newMembership = getEffectiveMembership(membershipPayload.membership);
-            if (oldMembership !== EffectiveMembership.Join && newMembership === EffectiveMembership.Join) {
-                // If we're joining an upgraded room, we'll want to make sure we don't proliferate
-                // the dead room in the list.
-                const createEvent = membershipPayload.room.currentState.getStateEvents(EventType.RoomCreate, "");
-                if (createEvent && createEvent.getContent()['predecessor']) {
-                    const prevRoom = this.matrixClient.getRoom(createEvent.getContent()['predecessor']['room_id']);
-                    if (prevRoom) {
-                        const isSticky = this.algorithm.stickyRoom === prevRoom;
-                        if (isSticky) {
-                            this.algorithm.setStickyRoom(null);
-                        }
-
-                        // Note: we hit the algorithm instead of our handleRoomUpdate() function to
-                        // avoid redundant updates.
-                        this.algorithm.handleRoomUpdate(prevRoom, RoomUpdateCause.RoomRemoved);
-                    }
-                }
-
-                await this.handleRoomUpdate(membershipPayload.room, RoomUpdateCause.NewRoom);
-                this.updateFn.trigger();
-                return;
-            }
-
-            if (oldMembership !== EffectiveMembership.Invite && newMembership === EffectiveMembership.Invite) {
-                await this.handleRoomUpdate(membershipPayload.room, RoomUpdateCause.NewRoom);
-                this.updateFn.trigger();
-                return;
-            }
-
-            // If it's not a join, it's transitioning into a different list (possibly historical)
-            if (oldMembership !== newMembership) {
-                await this.handleRoomUpdate(membershipPayload.room, RoomUpdateCause.PossibleTagChange);
-                this.updateFn.trigger();
-                return;
-            }
-        }
     }
 
     private async handleRoomUpdate(room: Room, cause: RoomUpdateCause): Promise<any> {

From 831efa435de20a760d1eae6a3098e47e5416c21c Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 12 Aug 2022 17:37:28 +0100
Subject: [PATCH 50/81] WIP SlidingRoomListStore

---
 src/components/views/rooms/RoomSublist.tsx   |  49 +-
 src/i18n/strings/en_EN.json                  |   1 -
 src/stores/room-list/SlidingRoomListStore.ts | 471 +++++--------------
 3 files changed, 128 insertions(+), 393 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 9b7f12d6d32..07c3cbfcc89 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -60,6 +60,7 @@ import { MatrixClientPeg } from "../../../MatrixClientPeg";
 import NotificationBadge from "./NotificationBadge";
 import RoomTile from "./RoomTile";
 import { logger } from "matrix-js-sdk/src/logger";
+import { SlidingSyncSortToFilter } from "../../../stores/room-list/SlidingRoomListStore";
 
 const SHOW_N_BUTTON_HEIGHT = 28; // As defined by CSS
 const RESIZE_HANDLE_HEIGHT = 4; // As defined by CSS
@@ -75,12 +76,6 @@ export interface IAuxButtonProps {
     dispatcher?: Dispatcher<ActionPayload>;
 }
 
-const SlidingSyncSortToFilter: Record<SortAlgorithm, string[]> = {
-    [SortAlgorithm.Alphabetic]: ["by_name", "by_recency"],
-    [SortAlgorithm.Recent]: ["by_highlight_count", "by_notification_count", "by_recency"],
-    [SortAlgorithm.Manual]: ["by_recency"],
-};
-
 interface IProps {
     forRooms: boolean;
     startAsHidden: boolean;
@@ -94,7 +89,6 @@ interface IProps {
     resizeNotifier: ResizeNotifier;
     extraTiles?: ReactComponentElement<typeof ExtraTile>[];
     slidingSyncFilter?: MSC3575Filter; // request JSON for the 'filters' object.
-    slidingSyncId?: string; // the list ID for this sublist
     onListCollapse?: (isExpanded: boolean) => void;
 }
 
@@ -135,7 +129,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         this.slidingSyncMode = SettingsStore.getValue("feature_sliding_sync");
         if (this.slidingSyncMode) {
             this.onSlidingSyncListUpdate = this.onSlidingSyncListUpdate.bind(this);
-            this.slidingSyncInit = SlidingSyncManager.instance.ensureListRegistered(SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId), {
+            this.slidingSyncInit = SlidingSyncManager.instance.ensureListRegistered(SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId), {
                 filters: this.props.slidingSyncFilter,
                 sort: SlidingSyncSortToFilter[SortAlgorithm.Recent], // default to recency sort
             });
@@ -149,9 +143,8 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             isResizing: false,
             isExpanded: !this.layout.isCollapsed,
             height: 0, // to be fixed in a moment, we need `rooms` to calculate this.
-            // sliding sync mode has no rooms initially as we need to fetch them via a request
             rooms: (
-                this.slidingSyncMode ? [] : arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || [])
+                arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || [])
             ),
             slidingSyncJoinedCount: 0,
             slidingSyncLoading: false,
@@ -223,7 +216,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 slidingSyncLoading: true,
             });
             SlidingSyncManager.instance.ensureListRegistered(
-                SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId),
+                SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId),
                 {
                     filters: filters,
                 },
@@ -302,7 +295,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             // listen for updates to this list
             SlidingSyncManager.instance.slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
             // fire the list data for the initial render
-            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId);
             const listData = SlidingSyncManager.instance.slidingSync.getListData(slidingSyncIndex);
             this.onSlidingSyncListUpdate(slidingSyncIndex, listData.joinedCount, listData.roomIndexToRoomId);
         }
@@ -322,7 +315,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     }
 
     private onSlidingSyncListUpdate(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>) {
-        const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+        const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId);
         if (listIndex !== slidingSyncIndex) {
             return;
         }
@@ -434,7 +427,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
     private onShowAllClick = async () => {
         if (this.slidingSyncMode) {
-            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId);
             await SlidingSyncManager.instance.ensureListRegistered(slidingSyncIndex, {
                 ranges: [
                     [0, this.state.slidingSyncJoinedCount-1],
@@ -497,32 +490,6 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     };
 
     private onTagSortChanged = async (sort: SortAlgorithm) => {
-	if (this.slidingSyncMode) {
-            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
-            switch (sort) {
-                case SortAlgorithm.Alphabetic:
-                    await SlidingSyncManager.instance.ensureListRegistered(
-                        slidingSyncIndex, {
-                            sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic],
-                        },
-                    );
-                    break;
-                case SortAlgorithm.Recent:
-                    await SlidingSyncManager.instance.ensureListRegistered(
-                        slidingSyncIndex, {
-                            sort: SlidingSyncSortToFilter[SortAlgorithm.Recent],
-                        },
-                    );
-                    break;
-                case SortAlgorithm.Manual:
-                    logger.error("cannot enable manual sort in sliding sync mode");
-                    break;
-                default:
-                    logger.error("unknown sort mode: ", sort);
-            }
-            // no need for forceUpdate here as the /sync response will fire onSlidingSyncListUpdate
-            return;
-        }
         RoomListStore.instance.setTagSorting(this.props.tagId, sort);
         this.forceUpdate();
     };
@@ -685,7 +652,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             let isAlphabetical = RoomListStore.instance.getTagSorting(this.props.tagId) === SortAlgorithm.Alphabetic;
             let isUnreadFirst = RoomListStore.instance.getListOrder(this.props.tagId) === ListAlgorithm.Importance;
             if (this.slidingSyncMode) {
-                const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.slidingSyncId);
+                const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId);
                 const slidingList = SlidingSyncManager.instance.slidingSync.getList(slidingSyncIndex);
                 isAlphabetical = slidingList.sort[0] === "by_name";
                 isUnreadFirst = (
diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json
index bf2bb6328bb..37301d25c42 100644
--- a/src/i18n/strings/en_EN.json
+++ b/src/i18n/strings/en_EN.json
@@ -898,7 +898,6 @@
     "Use new room breadcrumbs": "Use new room breadcrumbs",
     "Right panel stays open (defaults to room member list)": "Right panel stays open (defaults to room member list)",
     "Jump to date (adds /jumptodate and jump to date headers)": "Jump to date (adds /jumptodate and jump to date headers)",
-    "Don't send read receipts": "Don't send read receipts",
     "Sliding Sync mode (under active development)": "Sliding Sync mode (under active development)",
     "Send read receipts": "Send read receipts",
     "Right-click message context menu": "Right-click message context menu",
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index 91a19808107..8081b9f7bea 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -1,5 +1,5 @@
 /*
-Copyright 2018 - 2022 The Matrix.org Foundation C.I.C.
+Copyright 2022 The Matrix.org Foundation C.I.C.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,364 +16,80 @@ limitations under the License.
 
 import { MatrixClient } from "matrix-js-sdk/src/client";
 import { Room } from "matrix-js-sdk/src/models/room";
-import { isNullOrUndefined } from "matrix-js-sdk/src/utils";
 import { logger } from "matrix-js-sdk/src/logger";
-import { EventType } from "matrix-js-sdk/src/@types/event";
-
-import SettingsStore from "../../settings/SettingsStore";
-import { DefaultTagID, OrderedDefaultTagIDs, RoomUpdateCause, TagID } from "./models";
-import { IListOrderingMap, ITagMap, ITagSortingMap, ListAlgorithm, SortAlgorithm } from "./algorithms/models";
+import { RoomUpdateCause, TagID } from "./models";
+import { ITagMap, ListAlgorithm, SortAlgorithm } from "./algorithms/models";
 import { ActionPayload } from "../../dispatcher/payloads";
 import defaultDispatcher from "../../dispatcher/dispatcher";
-import { readReceiptChangeIsFor } from "../../utils/read-receipts";
-import { FILTER_CHANGED, IFilterCondition } from "./filters/IFilterCondition";
-import { RoomViewStore } from "../RoomViewStore";
-import { Algorithm, LIST_UPDATED_EVENT } from "./algorithms/Algorithm";
-import { EffectiveMembership, getEffectiveMembership } from "../../utils/membership";
-import RoomListLayoutStore from "./RoomListLayoutStore";
-import { MarkedExecution } from "../../utils/MarkedExecution";
+import { IFilterCondition } from "./filters/IFilterCondition";
 import { AsyncStoreWithClient } from "../AsyncStoreWithClient";
-import { RoomNotificationStateStore } from "../notifications/RoomNotificationStateStore";
-import { VisibilityProvider } from "./filters/VisibilityProvider";
-import { SpaceWatcher } from "./SpaceWatcher";
-import { IRoomTimelineActionPayload } from "../../actions/MatrixActionCreators";
 import { RoomListStore as Interface, RoomListStoreEvent } from "./Interface";
+import { SlidingSyncManager } from "../../SlidingSyncManager";
 
 interface IState {
     // state is tracked in underlying classes
 }
 
+export const SlidingSyncSortToFilter: Record<SortAlgorithm, string[]> = {
+    [SortAlgorithm.Alphabetic]: ["by_name", "by_recency"],
+    [SortAlgorithm.Recent]: ["by_highlight_count", "by_notification_count", "by_recency"],
+    [SortAlgorithm.Manual]: ["by_recency"],
+};
+
 export const LISTS_UPDATE_EVENT = RoomListStoreEvent.ListsUpdate;
 
 export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> implements Interface {
-    /**
-     * Set to true if you're running tests on the store. Should not be touched in
-     * any other environment.
-     */
-    public static TEST_MODE = false;
-
-    private initialListsGenerated = false;
-    private algorithm = new Algorithm();
-    private prefilterConditions: IFilterCondition[] = [];
-    private updateFn = new MarkedExecution(() => {
-        for (const tagId of Object.keys(this.orderedLists)) {
-            RoomNotificationStateStore.instance.getListState(tagId).setRooms(this.orderedLists[tagId]);
-        }
-        this.emit(LISTS_UPDATE_EVENT);
-    });
+    private tagIdToSortAlgo: Record<TagID,SortAlgorithm> = {};
 
     constructor() {
         super(defaultDispatcher);
         this.setMaxListeners(20); // RoomList + LeftPanel + 8xRoomSubList + spares
-        this.algorithm.start();
-    }
-
-    private setupWatchers() {
-        // TODO: Maybe destroy this if this class supports destruction
-        new SpaceWatcher(this);
-    }
-
-    public get orderedLists(): ITagMap {
-        if (!this.algorithm) return {}; // No tags yet.
-        return this.algorithm.getOrderedRooms();
     }
 
-    // Intended for test usage
-    public async resetStore() {
-        await this.reset();
-        this.prefilterConditions = [];
-        this.initialListsGenerated = false;
-
-        this.algorithm.off(LIST_UPDATED_EVENT, this.onAlgorithmListUpdated);
-        this.algorithm.off(FILTER_CHANGED, this.onAlgorithmListUpdated);
-        this.algorithm.stop();
-        this.algorithm = new Algorithm();
-        this.algorithm.on(LIST_UPDATED_EVENT, this.onAlgorithmListUpdated);
-        this.algorithm.on(FILTER_CHANGED, this.onAlgorithmListUpdated);
-
-        // Reset state without causing updates as the client will have been destroyed
-        // and downstream code will throw NPE errors.
-        await this.reset(null, true);
-    }
-
-    // Public for test usage. Do not call this.
-    public async makeReady(forcedClient?: MatrixClient) {
-        if (forcedClient) {
-            this.readyStore.useUnitTestClient(forcedClient);
+    public async setTagSorting(tagId: TagID, sort: SortAlgorithm) {
+        this.tagIdToSortAlgo[tagId] = sort;
+        const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
+        switch (sort) {
+            case SortAlgorithm.Alphabetic:
+                await SlidingSyncManager.instance.ensureListRegistered(
+                    slidingSyncIndex, {
+                        sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic],
+                    },
+                );
+                break;
+            case SortAlgorithm.Recent:
+                await SlidingSyncManager.instance.ensureListRegistered(
+                    slidingSyncIndex, {
+                        sort: SlidingSyncSortToFilter[SortAlgorithm.Recent],
+                    },
+                );
+                break;
+            case SortAlgorithm.Manual:
+                logger.error("cannot enable manual sort in sliding sync mode");
+                break;
+            default:
+                logger.error("unknown sort mode: ", sort);
         }
-
-        RoomViewStore.instance.addListener(() => this.handleRVSUpdate({}));
-        this.algorithm.on(LIST_UPDATED_EVENT, this.onAlgorithmListUpdated);
-        this.algorithm.on(FILTER_CHANGED, this.onAlgorithmFilterUpdated);
-        this.setupWatchers();
-
-        // Update any settings here, as some may have happened before we were logically ready.
-        logger.log("Regenerating room lists: Startup");
-        this.updateAlgorithmInstances();
-        this.regenerateAllLists({ trigger: false });
-        this.handleRVSUpdate({ trigger: false }); // fake an RVS update to adjust sticky room, if needed
-
-        this.updateFn.mark(); // we almost certainly want to trigger an update.
-        this.updateFn.trigger();
-    }
-
-    /**
-     * Handles suspected RoomViewStore changes.
-     * @param trigger Set to false to prevent a list update from being sent. Should only
-     * be used if the calling code will manually trigger the update.
-     */
-    private handleRVSUpdate({ trigger = true }) {
-    }
-
-    protected async onReady(): Promise<any> {
-        await this.makeReady();
-    }
-
-    protected async onNotReady(): Promise<any> {
-        await this.resetStore();
-    }
-
-    protected async onAction(payload: ActionPayload) {
-        // If we're not remotely ready, don't even bother scheduling the dispatch handling.
-        // This is repeated in the handler just in case things change between a decision here and
-        // when the timer fires.
-        const logicallyReady = this.matrixClient && this.initialListsGenerated;
-        if (!logicallyReady) return;
-
-        // We do this to intentionally break out of the current event loop task, allowing
-        // us to instead wait for a more convenient time to run our updates.
-        setImmediate(() => this.onDispatchAsync(payload));
-    }
-
-    protected async onDispatchAsync(payload: ActionPayload) {
-    }
-
-    private async handleRoomUpdate(room: Room, cause: RoomUpdateCause): Promise<any> {
-        if (cause === RoomUpdateCause.NewRoom && room.getMyMembership() === "invite") {
-            // Let the visibility provider know that there is a new invited room. It would be nice
-            // if this could just be an event that things listen for but the point of this is that
-            // we delay doing anything about this room until the VoipUserMapper had had a chance
-            // to do the things it needs to do to decide if we should show this room or not, so
-            // an even wouldn't et us do that.
-            await VisibilityProvider.instance.onNewInvitedRoom(room);
-        }
-
-        if (!VisibilityProvider.instance.isRoomVisible(room)) {
-            return; // don't do anything on rooms that aren't visible
-        }
-
-        if ((cause === RoomUpdateCause.NewRoom || cause === RoomUpdateCause.PossibleTagChange) &&
-            !this.prefilterConditions.every(c => c.isVisible(room))
-        ) {
-            return; // don't do anything on new/moved rooms which ought not to be shown
-        }
-
-        const shouldUpdate = this.algorithm.handleRoomUpdate(room, cause);
-        if (shouldUpdate) {
-            this.updateFn.mark();
-        }
-    }
-
-    private async recalculatePrefiltering() {
-        if (!this.algorithm) return;
-        if (!this.algorithm.hasTagSortingMap) return; // we're still loading
-
-        // Inhibit updates because we're about to lie heavily to the algorithm
-        this.algorithm.updatesInhibited = true;
-
-        // Figure out which rooms are about to be valid, and the state of affairs
-        const rooms = this.getPlausibleRooms();
-        const currentSticky = this.algorithm.stickyRoom;
-        const stickyIsStillPresent = currentSticky && rooms.includes(currentSticky);
-
-        // Reset the sticky room before resetting the known rooms so the algorithm
-        // doesn't freak out.
-        this.algorithm.setStickyRoom(null);
-        this.algorithm.setKnownRooms(rooms);
-
-        // Set the sticky room back, if needed, now that we have updated the store.
-        // This will use relative stickyness to the new room set.
-        if (stickyIsStillPresent) {
-            this.algorithm.setStickyRoom(currentSticky);
-        }
-
-        // Finally, mark an update and resume updates from the algorithm
-        this.updateFn.mark();
-        this.algorithm.updatesInhibited = false;
-    }
-
-    public setTagSorting(tagId: TagID, sort: SortAlgorithm) {
-        this.setAndPersistTagSorting(tagId, sort);
-        this.updateFn.trigger();
-    }
-
-    private setAndPersistTagSorting(tagId: TagID, sort: SortAlgorithm) {
-        this.algorithm.setTagSorting(tagId, sort);
-        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
-        localStorage.setItem(`mx_tagSort_${tagId}`, sort);
     }
 
     public getTagSorting(tagId: TagID): SortAlgorithm {
-        return this.algorithm.getTagSorting(tagId);
-    }
-
-    // noinspection JSMethodCanBeStatic
-    private getStoredTagSorting(tagId: TagID): SortAlgorithm {
-        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
-        return <SortAlgorithm>localStorage.getItem(`mx_tagSort_${tagId}`);
+        let algo = this.tagIdToSortAlgo[tagId];
+        if (!algo) {
+            logger.warn("SlidingRoomListStore.getTagSorting: no sort algorithm for tag ", tagId);
+            algo = SortAlgorithm.Recent; // why not, we have to do something..
+        }
+        return algo;
     }
 
-    // logic must match calculateListOrder
-    private calculateTagSorting(tagId: TagID): SortAlgorithm {
-        const isDefaultRecent = tagId === DefaultTagID.Invite || tagId === DefaultTagID.DM;
-        const defaultSort = isDefaultRecent ? SortAlgorithm.Recent : SortAlgorithm.Alphabetic;
-        const settingAlphabetical = SettingsStore.getValue("RoomList.orderAlphabetically", null, true);
-        const definedSort = this.getTagSorting(tagId);
-        const storedSort = this.getStoredTagSorting(tagId);
-
-        // We use the following order to determine which of the 4 flags to use:
-        // Stored > Settings > Defined > Default
-
-        let tagSort = defaultSort;
-        if (storedSort) {
-            tagSort = storedSort;
-        } else if (!isNullOrUndefined(settingAlphabetical)) {
-            tagSort = settingAlphabetical ? SortAlgorithm.Alphabetic : SortAlgorithm.Recent;
-        } else if (definedSort) {
-            tagSort = definedSort;
-        } // else default (already set)
-
-        return tagSort;
-    }
 
     public setListOrder(tagId: TagID, order: ListAlgorithm) {
-        this.setAndPersistListOrder(tagId, order);
-        this.updateFn.trigger();
+        // TODO?
     }
 
-    private setAndPersistListOrder(tagId: TagID, order: ListAlgorithm) {
-        this.algorithm.setListOrdering(tagId, order);
-        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
-        localStorage.setItem(`mx_listOrder_${tagId}`, order);
-    }
 
     public getListOrder(tagId: TagID): ListAlgorithm {
-        return this.algorithm.getListOrdering(tagId);
-    }
-
-    // noinspection JSMethodCanBeStatic
-    private getStoredListOrder(tagId: TagID): ListAlgorithm {
-        // TODO: Per-account? https://github.com/vector-im/element-web/issues/14114
-        return <ListAlgorithm>localStorage.getItem(`mx_listOrder_${tagId}`);
-    }
-
-    // logic must match calculateTagSorting
-    private calculateListOrder(tagId: TagID): ListAlgorithm {
-        const defaultOrder = ListAlgorithm.Natural;
-        const settingImportance = SettingsStore.getValue("RoomList.orderByImportance", null, true);
-        const definedOrder = this.getListOrder(tagId);
-        const storedOrder = this.getStoredListOrder(tagId);
-
-        // We use the following order to determine which of the 4 flags to use:
-        // Stored > Settings > Defined > Default
-
-        let listOrder = defaultOrder;
-        if (storedOrder) {
-            listOrder = storedOrder;
-        } else if (!isNullOrUndefined(settingImportance)) {
-            listOrder = settingImportance ? ListAlgorithm.Importance : ListAlgorithm.Natural;
-        } else if (definedOrder) {
-            listOrder = definedOrder;
-        } // else default (already set)
-
-        return listOrder;
-    }
-
-    private updateAlgorithmInstances() {
-        // We'll require an update, so mark for one. Marking now also prevents the calls
-        // to setTagSorting and setListOrder from causing triggers.
-        this.updateFn.mark();
-
-        for (const tag of Object.keys(this.orderedLists)) {
-            const definedSort = this.getTagSorting(tag);
-            const definedOrder = this.getListOrder(tag);
-
-            const tagSort = this.calculateTagSorting(tag);
-            const listOrder = this.calculateListOrder(tag);
-
-            if (tagSort !== definedSort) {
-                this.setAndPersistTagSorting(tag, tagSort);
-            }
-            if (listOrder !== definedOrder) {
-                this.setAndPersistListOrder(tag, listOrder);
-            }
-        }
-    }
-
-    private onAlgorithmListUpdated = (forceUpdate: boolean) => {
-        this.updateFn.mark();
-        if (forceUpdate) this.updateFn.trigger();
-    };
-
-    private onAlgorithmFilterUpdated = () => {
-        // The filter can happen off-cycle, so trigger an update. The filter will have
-        // already caused a mark.
-        this.updateFn.trigger();
-    };
-
-    private onPrefilterUpdated = async () => {
-        await this.recalculatePrefiltering();
-        this.updateFn.trigger();
-    };
-
-    private getPlausibleRooms(): Room[] {
-        if (!this.matrixClient) return [];
-
-        let rooms = this.matrixClient.getVisibleRooms().filter(r => VisibilityProvider.instance.isRoomVisible(r));
-
-        if (this.prefilterConditions.length > 0) {
-            rooms = rooms.filter(r => {
-                for (const filter of this.prefilterConditions) {
-                    if (!filter.isVisible(r)) {
-                        return false;
-                    }
-                }
-                return true;
-            });
-        }
-
-        return rooms;
-    }
-
-    /**
-     * Regenerates the room whole room list, discarding any previous results.
-     *
-     * Note: This is only exposed externally for the tests. Do not call this from within
-     * the app.
-     * @param trigger Set to false to prevent a list update from being sent. Should only
-     * be used if the calling code will manually trigger the update.
-     */
-    public regenerateAllLists({ trigger = true }) {
-        logger.warn("Regenerating all room lists");
-
-        const rooms = this.getPlausibleRooms();
-
-        const sorts: ITagSortingMap = {};
-        const orders: IListOrderingMap = {};
-        const allTags = [...OrderedDefaultTagIDs];
-        for (const tagId of allTags) {
-            sorts[tagId] = this.calculateTagSorting(tagId);
-            orders[tagId] = this.calculateListOrder(tagId);
-
-            RoomListLayoutStore.instance.ensureLayoutExists(tagId);
-        }
-
-        this.algorithm.populateTags(sorts, orders);
-        this.algorithm.setKnownRooms(rooms);
-
-        this.initialListsGenerated = true;
-
-        if (trigger) this.updateFn.trigger();
+        // TODO: handle unread msgs first?
+        return ListAlgorithm.Natural;
     }
 
     /**
@@ -382,11 +98,8 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
      * @param {IFilterCondition} filter The filter condition to add.
      */
     public async addFilter(filter: IFilterCondition): Promise<void> {
-        let promise = Promise.resolve();
-        filter.on(FILTER_CHANGED, this.onPrefilterUpdated);
-        this.prefilterConditions.push(filter);
-        promise = this.recalculatePrefiltering();
-        promise.then(() => this.updateFn.trigger());
+        // Do nothing, the filters are only used by SpaceWatcher to see if a room should appear
+        // in the room list. We do not support arbitrary code for filters in sliding sync.
     }
 
     /**
@@ -397,19 +110,8 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
      * @param {IFilterCondition} filter The filter condition to remove.
      */
     public removeFilter(filter: IFilterCondition): void {
-        let promise = Promise.resolve();
-        let removed = false;
-        const idx = this.prefilterConditions.indexOf(filter);
-        if (idx >= 0) {
-            filter.off(FILTER_CHANGED, this.onPrefilterUpdated);
-            this.prefilterConditions.splice(idx, 1);
-            promise = this.recalculatePrefiltering();
-            removed = true;
-        }
-
-        if (removed) {
-            promise.then(() => this.updateFn.trigger());
-        }
+        // Do nothing, the filters are only used by SpaceWatcher to see if a room should appear
+        // in the room list. We do not support arbitrary code for filters in sliding sync.
     }
 
     /**
@@ -420,9 +122,21 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
      * @returns The tags for the room.
      */
     public getTagsForRoom(room: Room): TagID[] {
-        const algorithmTags = this.algorithm.getTagsForRoom(room);
-        if (!algorithmTags) return [DefaultTagID.Untagged];
-        return algorithmTags;
+        // check all lists for each tag we know about and see if the room is there
+        const tags = [];
+        for (let tagId in this.tagIdToSortAlgo) {
+            const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
+            let { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(index);
+            for (let roomIndex in roomIndexToRoomId) {
+                const roomId = roomIndexToRoomId[roomIndex];
+                if (roomId === room.roomId) {
+                    tags.push(tagId);
+                    break;
+                }
+            }
+        }
+        console.log("SlidingRoomListStore.getTagsForRoom ", room.roomId, " => ", tags);
+        return tags;
     }
 
     /**
@@ -433,7 +147,62 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
      * @param {RoomUpdateCause} cause The cause to update for.
      */
     public async manualRoomUpdate(room: Room, cause: RoomUpdateCause) {
-        await this.handleRoomUpdate(room, cause);
-        this.updateFn.trigger();
+        // TODO: this is only used when you forget a room, not that important for now.
+    }
+
+    public get orderedLists(): ITagMap {
+        const tagMap: ITagMap = {};
+        for (let tagId in this.tagIdToSortAlgo) {
+            const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
+            let { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(index);
+            const rooms = [];
+            for (let roomIndex in roomIndexToRoomId) {
+                const roomId = roomIndexToRoomId[roomIndex];
+                const r = this.matrixClient.getRoom(roomId);
+                if (r) {
+                    rooms.push(r);
+                }
+            }
+            tagMap[tagId] = rooms;
+        }
+        console.log("SlidingRoomListStore.orderedLists", tagMap);
+        return tagMap;
+    }
+
+
+    // Intended for test usage
+    public async resetStore() {
+        // Test function
+    }
+
+    // Public for test usage. Do not call this.
+    public async makeReady(forcedClient?: MatrixClient) {
+        // Test function
+    }
+
+    /**
+     * Regenerates the room whole room list, discarding any previous results.
+     *
+     * Note: This is only exposed externally for the tests. Do not call this from within
+     * the app.
+     * @param trigger Set to false to prevent a list update from being sent. Should only
+     * be used if the calling code will manually trigger the update.
+     */
+    public regenerateAllLists({ trigger = true }) {
+        // Test function
+    }
+
+    protected async onReady(): Promise<any> {
+        await this.makeReady();
+    }
+
+    protected async onNotReady(): Promise<any> {
+        await this.resetStore();
+    }
+
+    protected async onAction(payload: ActionPayload) {
+    }
+
+    protected async onDispatchAsync(payload: ActionPayload) {
     }
 }

From b7e1bd0ecde9863ff67a4642b27394244f54a068 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 12 Aug 2022 19:01:25 +0100
Subject: [PATCH 51/81] Add most sliding sync logic to SlidingRoomListStore

Still lots of logic in RoomSublist. Broken things:
 - Join count is wrong completely.
 - No skeleton placeholder when switching spaces.
---
 src/SlidingSyncManager.ts                    |   9 ++
 src/components/views/rooms/RoomList.tsx      |  54 +-------
 src/components/views/rooms/RoomSublist.tsx   |  93 -------------
 src/stores/room-list/SlidingRoomListStore.ts | 137 +++++++++++++++----
 4 files changed, 123 insertions(+), 170 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index c92dbd43338..a7e1a3e3a85 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -127,6 +127,15 @@ export class SlidingSyncManager {
         return this.slidingSync;
     }
 
+    public listIdForIndex(index: number): string | null {
+        for (const listId in this.listIdToIndex) {
+            if (this.listIdToIndex[listId] === index) {
+                return listId;
+            }
+        }
+        return null;
+    }
+
     /**
      * Allocate or retrieve the list index for an arbitrary list ID. For example SlidingSyncManager.ListSpaces
      * @param listId A string which represents the list.
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index a9273a06cd7..226c6118586 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -17,7 +17,6 @@ limitations under the License.
 import * as fbEmitter from "fbemitter";
 import { EventType, RoomType } from "matrix-js-sdk/src/@types/event";
 import { Room } from "matrix-js-sdk/src/models/room";
-import { MSC3575Filter } from "matrix-js-sdk/src/sliding-sync";
 import React, { ComponentType, createRef, ReactComponentElement, RefObject } from "react";
 
 import { IState as IRovingTabIndexState, RovingTabIndexProvider } from "../../../accessibility/RovingTabIndex";
@@ -463,7 +462,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
     private getRoomDelta = (roomId: string, delta: number, unread = false) => {
         const lists = RoomListStore.instance.orderedLists;
         const rooms: Room[] = [];
-        TAG_ORDER.forEach(t => {
+        ALWAYS_VISIBLE_TAGS.forEach(t => { // FIXME: read from store?
             let listRooms = lists[t];
 
             if (unread) {
@@ -584,14 +583,11 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
     }
 
     private renderSublists(): React.ReactElement[] {
-        if (SettingsStore.getValue("feature_sliding_sync")) {
-            return this.renderSlidingSyncLists();
-        }
         // show a skeleton UI if the user is in no rooms and they are not filtering and have no suggested rooms
         const showSkeleton = !this.state.suggestedRooms?.length &&
             Object.values(RoomListStore.instance.orderedLists).every(list => !list?.length);
 
-        return TAG_ORDER
+        return ALWAYS_VISIBLE_TAGS // FIXME: read from store?
             .map(orderedTagId => {
                 let extraTiles = null;
                 if (orderedTagId === DefaultTagID.Suggested) {
@@ -648,52 +644,6 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
             });
     }
 
-    private renderSlidingSyncLists(): React.ReactElement[] {
-        // TODO: Currently sliding sync does not support Favourites, Low Priority or Server Notice groupings.
-        const tagOrder = [
-            DefaultTagID.Invite,
-            // DefaultTagID.Favourite,
-            DefaultTagID.DM,
-            DefaultTagID.Untagged,
-        ];
-        const tagToSlidingSyncFilters: Record<string,MSC3575Filter> = {
-            [DefaultTagID.Invite]: {
-                is_invite: true,
-            },
-            [DefaultTagID.DM]: {
-                is_dm: true,
-                is_invite: false,
-                is_tombstoned: false,
-            },
-            [DefaultTagID.Untagged]: {
-                is_dm: false,
-                is_invite: false,
-                is_tombstoned: false,
-                not_room_types: ["m.space"],
-                spaces: SpaceStore.instance.activeSpaceRoom ? [SpaceStore.instance.activeSpaceRoom.roomId] : undefined,
-            },
-        };
-        return tagOrder.map((tag, index) => {
-            const aesthetics = TAG_AESTHETICS[tag];
-            return <RoomSublist
-                key={`sublist-${tag}`}
-                tagId={tag}
-                forRooms={true}
-                slidingSyncFilter={tagToSlidingSyncFilters[tag]}
-                slidingSyncId={"list_"+index}
-                startAsHidden={aesthetics.defaultHidden}
-                label={aesthetics.sectionLabelRaw ? aesthetics.sectionLabelRaw : _t(aesthetics.sectionLabel)}
-                AuxButtonComponent={aesthetics.AuxButtonComponent}
-                isMinimized={this.props.isMinimized}
-                extraTiles={null}
-                resizeNotifier={this.props.resizeNotifier}
-                alwaysVisible={false}
-                onListCollapse={this.props.onListCollapse}
-                forceExpanded={false}
-            />;
-        });
-    }
-
     public focus(): void {
         // focus the first focusable element in this aria treeview widget
         const treeItems = this.treeRef.current?.querySelectorAll<HTMLElement>('[role="treeitem"]');
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 07c3cbfcc89..cf483014ba7 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -17,8 +17,6 @@ limitations under the License.
 */
 
 import { Room } from "matrix-js-sdk/src/models/room";
-import * as utils from "matrix-js-sdk/src/utils";
-import { MSC3575Filter, SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import classNames from 'classnames';
 import { Dispatcher } from "flux";
 import { Enable, Resizable } from "re-resizable";
@@ -56,11 +54,8 @@ import AccessibleTooltipButton from "../elements/AccessibleTooltipButton";
 import ExtraTile from "./ExtraTile";
 import SettingsStore from "../../../settings/SettingsStore";
 import { SlidingSyncManager } from "../../../SlidingSyncManager";
-import { MatrixClientPeg } from "../../../MatrixClientPeg";
 import NotificationBadge from "./NotificationBadge";
 import RoomTile from "./RoomTile";
-import { logger } from "matrix-js-sdk/src/logger";
-import { SlidingSyncSortToFilter } from "../../../stores/room-list/SlidingRoomListStore";
 
 const SHOW_N_BUTTON_HEIGHT = 28; // As defined by CSS
 const RESIZE_HANDLE_HEIGHT = 4; // As defined by CSS
@@ -88,7 +83,6 @@ interface IProps {
     forceExpanded?: boolean;
     resizeNotifier: ResizeNotifier;
     extraTiles?: ReactComponentElement<typeof ExtraTile>[];
-    slidingSyncFilter?: MSC3575Filter; // request JSON for the 'filters' object.
     onListCollapse?: (isExpanded: boolean) => void;
 }
 
@@ -121,19 +115,11 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     private notificationState: ListNotificationState;
 
     private slidingSyncMode: boolean;
-    private slidingSyncInit: Promise<unknown>; // we don't care about the resulting list
 
     constructor(props: IProps) {
         super(props);
         // when this setting is toggled it restarts the app so it's safe to not watch this.
         this.slidingSyncMode = SettingsStore.getValue("feature_sliding_sync");
-        if (this.slidingSyncMode) {
-            this.onSlidingSyncListUpdate = this.onSlidingSyncListUpdate.bind(this);
-            this.slidingSyncInit = SlidingSyncManager.instance.ensureListRegistered(SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId), {
-                filters: this.props.slidingSyncFilter,
-                sort: SlidingSyncSortToFilter[SortAlgorithm.Recent], // default to recency sort
-            });
-        }
 
         this.layout = RoomListLayoutStore.instance.getLayoutFor(this.props.tagId);
         this.heightAtStart = 0;
@@ -208,24 +194,6 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         if (RoomSublist.calcNumTiles(prevState.rooms, prevExtraTiles) !== this.numTiles) {
             this.setState({ height: this.calculateInitialHeight() });
         }
-        if (this.slidingSyncMode && !utils.deepCompare(prevProps.slidingSyncFilter.spaces, this.props.slidingSyncFilter.spaces)) {
-            // spaces filter has changed, update the registration
-            const filters = this.props.slidingSyncFilter;
-            filters.spaces = this.props.slidingSyncFilter.spaces;
-            this.setState({
-                slidingSyncLoading: true,
-            });
-            SlidingSyncManager.instance.ensureListRegistered(
-                SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId),
-                {
-                    filters: filters,
-                },
-            ).then(() => {
-                this.setState({
-                    slidingSyncLoading: false,
-                });
-            });
-        }
     }
 
     public shouldComponentUpdate(nextProps: Readonly<IProps>, nextState: Readonly<IState>): boolean {
@@ -285,20 +253,8 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     }
 
     public async componentDidMount() {
-        if (this.slidingSyncMode) {
-            await this.slidingSyncInit;
-        }
-
         this.dispatcherRef = defaultDispatcher.register(this.onAction);
         RoomListStore.instance.on(LISTS_UPDATE_EVENT, this.onListsUpdated);
-        if (this.slidingSyncMode) {
-            // listen for updates to this list
-            SlidingSyncManager.instance.slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
-            // fire the list data for the initial render
-            const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId);
-            const listData = SlidingSyncManager.instance.slidingSync.getListData(slidingSyncIndex);
-            this.onSlidingSyncListUpdate(slidingSyncIndex, listData.joinedCount, listData.roomIndexToRoomId);
-        }
 
         // Using the passive option to not block the main thread
         // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#improving_scrolling_performance_with_passive_listeners
@@ -307,59 +263,10 @@ export default class RoomSublist extends React.Component<IProps, IState> {
 
     public componentWillUnmount() {
         defaultDispatcher.unregister(this.dispatcherRef);
-        if (this.slidingSyncMode) {
-            SlidingSyncManager.instance.slidingSync.off(SlidingSyncEvent.List, this.onSlidingSyncListUpdate);
-        }
         RoomListStore.instance.off(LISTS_UPDATE_EVENT, this.onListsUpdated);
         this.tilesRef.current?.removeEventListener("scroll", this.onScrollPrevent);
     }
 
-    private onSlidingSyncListUpdate(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>) {
-        const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId);
-        if (listIndex !== slidingSyncIndex) {
-            return;
-        }
-
-        const orderedRoomIndexes = Object.keys(roomIndexToRoomId).map((numStr) => {
-            return Number(numStr);
-        }).sort((a, b) => {
-            return a-b;
-        });
-        const seenRoomIds = new Set<string>();
-        const orderedRoomIds = orderedRoomIndexes.map((i) => {
-            const rid = roomIndexToRoomId[i];
-            if (seenRoomIds.has(rid)) {
-                logger.error("room " + rid + " already has an index position: duplicate room!");
-            }
-            seenRoomIds.add(rid);
-            if (!rid) {
-                throw new Error("index " + i + " has no room ID: Map => " + JSON.stringify(roomIndexToRoomId));
-            }
-            return rid;
-        });
-        logger.debug(
-            "onSlidingSyncListUpdate", listIndex, "join=", joinCount, " rooms:",
-            orderedRoomIds.length < 30 ? orderedRoomIds : orderedRoomIds.length,
-        );
-        // now set the rooms
-        this.setState({
-            rooms: orderedRoomIds.map((roomId, index) => {
-                const r = MatrixClientPeg.get().getRoom(roomId);
-                return r;
-            }),
-            slidingSyncJoinedCount: joinCount,
-        });
-
-        if (this.props.forceExpanded && orderedRoomIds.length < joinCount) {
-            // expand the range for this list as we are forcibly showing everything
-            SlidingSyncManager.instance.ensureListRegistered(slidingSyncIndex, {
-                ranges: [
-                    [0, joinCount-1],
-                ],
-            });
-        }
-    }
-
     private onListsUpdated = () => {
         const stateUpdates: IState & any = {}; // &any is to avoid a cast on the initializer
 
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index 8081b9f7bea..e7ec87d0b11 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -14,10 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MatrixClient } from "matrix-js-sdk/src/client";
 import { Room } from "matrix-js-sdk/src/models/room";
 import { logger } from "matrix-js-sdk/src/logger";
-import { RoomUpdateCause, TagID } from "./models";
+import { RoomUpdateCause, TagID, OrderedDefaultTagIDs, DefaultTagID } from "./models";
 import { ITagMap, ListAlgorithm, SortAlgorithm } from "./algorithms/models";
 import { ActionPayload } from "../../dispatcher/payloads";
 import defaultDispatcher from "../../dispatcher/dispatcher";
@@ -25,6 +24,9 @@ import { IFilterCondition } from "./filters/IFilterCondition";
 import { AsyncStoreWithClient } from "../AsyncStoreWithClient";
 import { RoomListStore as Interface, RoomListStoreEvent } from "./Interface";
 import { SlidingSyncManager } from "../../SlidingSyncManager";
+import { MSC3575Filter, SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
+import SpaceStore from "../spaces/SpaceStore";
+import { MetaSpace, SpaceKey, UPDATE_SELECTED_SPACE } from "../spaces";
 
 interface IState {
     // state is tracked in underlying classes
@@ -36,10 +38,37 @@ export const SlidingSyncSortToFilter: Record<SortAlgorithm, string[]> = {
     [SortAlgorithm.Manual]: ["by_recency"],
 };
 
+const filterConditions: Record<TagID, MSC3575Filter> = {
+    [DefaultTagID.Invite]: {
+        is_invite: true,
+    },
+    // TODO
+    // DefaultTagID.Favourite,
+    // DefaultTagID.SavedItems,
+    [DefaultTagID.DM]: {
+        is_dm: true,
+        is_invite: false,
+        is_tombstoned: false,
+    },
+    [DefaultTagID.Untagged]: {
+        is_dm: false,
+        is_invite: false,
+        is_tombstoned: false,
+        not_room_types: ["m.space"],
+        // spaces filter added dynamically
+    },
+    // TODO
+    // DefaultTagID.LowPriority,
+    // DefaultTagID.ServerNotice,
+    // DefaultTagID.Suggested,
+    // DefaultTagID.Archived,
+};
+
 export const LISTS_UPDATE_EVENT = RoomListStoreEvent.ListsUpdate;
 
 export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> implements Interface {
     private tagIdToSortAlgo: Record<TagID,SortAlgorithm> = {};
+    private tagMap: ITagMap = {};
 
     constructor() {
         super(defaultDispatcher);
@@ -47,6 +76,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     public async setTagSorting(tagId: TagID, sort: SortAlgorithm) {
+        console.log("SlidingRoomListStore.setTagSorting ", tagId, sort);
         this.tagIdToSortAlgo[tagId] = sort;
         const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
         switch (sort) {
@@ -151,22 +181,88 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     public get orderedLists(): ITagMap {
-        const tagMap: ITagMap = {};
-        for (let tagId in this.tagIdToSortAlgo) {
-            const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
-            let { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(index);
-            const rooms = [];
-            for (let roomIndex in roomIndexToRoomId) {
-                const roomId = roomIndexToRoomId[roomIndex];
-                const r = this.matrixClient.getRoom(roomId);
-                if (r) {
-                    rooms.push(r);
-                }
+        return this.tagMap;
+    }
+
+    private refreshOrderedLists(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>): void {
+        const tagMap = this.tagMap;
+        const tagId = SlidingSyncManager.instance.listIdForIndex(listIndex);
+        // order from low to high
+        const orderedRoomIndexes = Object.keys(roomIndexToRoomId).map((numStr) => {
+            return Number(numStr);
+        }).sort((a, b) => {
+            return a-b;
+        });
+        const seenRoomIds = new Set<string>();
+        const orderedRoomIds = orderedRoomIndexes.map((i) => {
+            const rid = roomIndexToRoomId[i];
+            if (seenRoomIds.has(rid)) {
+                logger.error("room " + rid + " already has an index position: duplicate room!");
             }
-            tagMap[tagId] = rooms;
+            seenRoomIds.add(rid);
+            if (!rid) {
+                throw new Error("index " + i + " has no room ID: Map => " + JSON.stringify(roomIndexToRoomId));
+            }
+            return rid;
+        });
+        logger.debug(
+            "SlidingRoomListStore.refreshOrderedLists", listIndex, "join=", joinCount, " rooms:",
+            orderedRoomIds.length < 30 ? orderedRoomIds : orderedRoomIds.length,
+        );
+        // now set the rooms
+        const rooms = orderedRoomIds.map((roomId) => {
+            return this.matrixClient.getRoom(roomId);
+        })
+        tagMap[tagId] = rooms;
+        this.tagMap = tagMap;
+    }
+
+    private onSlidingSyncListUpdate(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>) {
+        this.refreshOrderedLists(listIndex, joinCount, roomIndexToRoomId);
+        // let the UI update
+        this.emit(LISTS_UPDATE_EVENT);
+    }
+
+    protected async onReady(): Promise<any> {
+        console.log("SlidingRoomListStore.onReady");
+        // permanent listener, we never get destroyed. Could be an issue if we want to test this in isolation.
+        SlidingSyncManager.instance.slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate.bind(this));
+        SpaceStore.instance.on(UPDATE_SELECTED_SPACE, this.onSelectedSpaceUpdated.bind(this));
+        if (SpaceStore.instance.activeSpace) {
+            this.onSelectedSpaceUpdated(SpaceStore.instance.activeSpace, false);
         }
-        console.log("SlidingRoomListStore.orderedLists", tagMap);
-        return tagMap;
+
+        // sliding sync has an initial response for spaces. Now request all the lists.
+        // We do the spaces list _first_ to avoid potential flickering on DefaultTagID.Untagged list
+        // which would be caused by initially having no `spaces` filter set, and then suddenly setting one.
+        OrderedDefaultTagIDs.forEach((tagId) => {
+            const filter = filterConditions[tagId];
+            if (!filter) {
+                console.log("SlidingRoomListStore.onReady unsupported list ", tagId);
+                return; // we do not support this list yet.
+            }
+            const sort = SortAlgorithm.Recent; // default to recency sort, TODO: read from config
+            this.tagIdToSortAlgo[tagId] = sort;
+            // don't bother waiting, it'll happen eventually and then we'll update it via callbacks on slidingSync
+            SlidingSyncManager.instance.ensureListRegistered(SlidingSyncManager.instance.getOrAllocateListIndex(tagId), {
+                filters: filter,
+                sort: SlidingSyncSortToFilter[sort],
+            });
+        });
+    }
+
+    private onSelectedSpaceUpdated = (activeSpace: SpaceKey, allRoomsInHome: boolean) => {
+        console.log("SlidingRoomListStore.onSelectedSpaceUpdated", activeSpace);
+        // update the untagged filter
+        const tagID = DefaultTagID.Untagged;
+        const filters = filterConditions[tagID];
+        filters.spaces = (activeSpace && activeSpace != MetaSpace.Home) ? [activeSpace] : undefined;
+        SlidingSyncManager.instance.ensureListRegistered(
+            SlidingSyncManager.instance.getOrAllocateListIndex(tagID),
+            {
+                filters: filters,
+            },
+        );
     }
 
 
@@ -175,11 +271,6 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         // Test function
     }
 
-    // Public for test usage. Do not call this.
-    public async makeReady(forcedClient?: MatrixClient) {
-        // Test function
-    }
-
     /**
      * Regenerates the room whole room list, discarding any previous results.
      *
@@ -192,10 +283,6 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         // Test function
     }
 
-    protected async onReady(): Promise<any> {
-        await this.makeReady();
-    }
-
     protected async onNotReady(): Promise<any> {
         await this.resetStore();
     }

From 150b0122240b46c9617f679c36b8637ccefa3d36 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 17 Aug 2022 09:48:16 +0100
Subject: [PATCH 52/81] Migrate joined count to SS RLS

---
 src/components/views/rooms/RoomSublist.tsx   |  9 ++++-----
 src/stores/room-list/Interface.ts            |  9 +++++++++
 src/stores/room-list/RoomListStore.ts        |  5 +++++
 src/stores/room-list/SlidingRoomListStore.ts | 14 ++++++++++----
 4 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index cf483014ba7..391cee4db94 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -101,7 +101,6 @@ interface IState {
     height: number;
     rooms: Room[];
     filteredExtraTiles?: ReactComponentElement<typeof ExtraTile>[];
-    slidingSyncJoinedCount?: number;
     slidingSyncLoading: boolean;
 }
 
@@ -132,7 +131,6 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             rooms: (
                 arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || [])
             ),
-            slidingSyncJoinedCount: 0,
             slidingSyncLoading: false,
         };
         // Why Object.assign() and not this.state.height? Because TypeScript says no.
@@ -335,9 +333,10 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     private onShowAllClick = async () => {
         if (this.slidingSyncMode) {
             const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(this.props.tagId);
+            const count = RoomListStore.instance.getCount(this.props.tagId);
             await SlidingSyncManager.instance.ensureListRegistered(slidingSyncIndex, {
                 ranges: [
-                    [0, this.state.slidingSyncJoinedCount-1],
+                    [0, count],
                 ],
             });
         }
@@ -776,7 +775,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             // tiles visible, it becomes 'show less'.
             let showNButton = null;
             const hasMoreSlidingSync = (
-                this.slidingSyncMode && (this.state.slidingSyncJoinedCount > this.state.rooms.length)
+                this.slidingSyncMode && (RoomListStore.instance.getCount(this.props.tagId) > this.state.rooms.length)
             );
 
             if ((maxTilesPx > this.state.height) || hasMoreSlidingSync) {
@@ -785,7 +784,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 const amountFullyShown = Math.floor(nonPaddedHeight / this.layout.tileHeight);
                 let numMissing = this.numTiles - amountFullyShown;
                 if (this.slidingSyncMode) {
-                    numMissing = this.state.slidingSyncJoinedCount - amountFullyShown;
+                    numMissing = RoomListStore.instance.getCount(this.props.tagId) - amountFullyShown;
                 }
                 const label = _t("Show %(count)s more", { count: numMissing });
                 let showMoreText = (
diff --git a/src/stores/room-list/Interface.ts b/src/stores/room-list/Interface.ts
index ab538709896..70e21ae7e69 100644
--- a/src/stores/room-list/Interface.ts
+++ b/src/stores/room-list/Interface.ts
@@ -33,6 +33,15 @@ export interface RoomListStore extends EventEmitter {
      */
     get orderedLists(): ITagMap;
 
+    /**
+     * Return the total number of rooms in this list. Prefer this method to
+     * RoomListStore.orderedLists[tagId].length because the client may not
+     * be aware of all the rooms in this list (e.g in Sliding Sync).
+     * @param tagId the tag to get the room count for.
+     * @returns the number of rooms in this list, or 0 if the list is unknown.
+     */
+    getCount(tagId: TagID): number;
+
     /**
      * Set the sort algorithm for the specified tag.
      * @param tagId the tag to set the algorithm for
diff --git a/src/stores/room-list/RoomListStore.ts b/src/stores/room-list/RoomListStore.ts
index ecd75cfb28d..41115dc0abf 100644
--- a/src/stores/room-list/RoomListStore.ts
+++ b/src/stores/room-list/RoomListStore.ts
@@ -586,6 +586,11 @@ export class RoomListStoreClass extends AsyncStoreWithClient<IState> implements
         return algorithmTags;
     }
 
+    public getCount(tagId: TagID): number {
+        // The room list store knows about all the rooms, so just return the length.
+        return this.orderedLists[tagId].length || 0;
+    }
+
     /**
      * Manually update a room with a given cause. This should only be used if the
      * room list store would otherwise be incapable of doing the update itself. Note
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index e7ec87d0b11..600b4cc2de7 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -69,6 +69,7 @@ export const LISTS_UPDATE_EVENT = RoomListStoreEvent.ListsUpdate;
 export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> implements Interface {
     private tagIdToSortAlgo: Record<TagID,SortAlgorithm> = {};
     private tagMap: ITagMap = {};
+    private counts: Record<TagID, number> = {};
 
     constructor() {
         super(defaultDispatcher);
@@ -111,6 +112,10 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         return algo;
     }
 
+    public getCount(tagId: TagID): number {
+        return this.counts[tagId] || 0;
+    }
+
 
     public setListOrder(tagId: TagID, order: ListAlgorithm) {
         // TODO?
@@ -184,9 +189,8 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         return this.tagMap;
     }
 
-    private refreshOrderedLists(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>): void {
+    private refreshOrderedLists(tagId: string, roomIndexToRoomId: Record<number, string>): void {
         const tagMap = this.tagMap;
-        const tagId = SlidingSyncManager.instance.listIdForIndex(listIndex);
         // order from low to high
         const orderedRoomIndexes = Object.keys(roomIndexToRoomId).map((numStr) => {
             return Number(numStr);
@@ -206,7 +210,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
             return rid;
         });
         logger.debug(
-            "SlidingRoomListStore.refreshOrderedLists", listIndex, "join=", joinCount, " rooms:",
+            "SlidingRoomListStore.refreshOrderedLists ", tagId, " rooms:",
             orderedRoomIds.length < 30 ? orderedRoomIds : orderedRoomIds.length,
         );
         // now set the rooms
@@ -218,7 +222,9 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     private onSlidingSyncListUpdate(listIndex: number, joinCount: number, roomIndexToRoomId: Record<number, string>) {
-        this.refreshOrderedLists(listIndex, joinCount, roomIndexToRoomId);
+        const tagId = SlidingSyncManager.instance.listIdForIndex(listIndex);
+        this.counts[tagId]= joinCount;
+        this.refreshOrderedLists(tagId, roomIndexToRoomId);
         // let the UI update
         this.emit(LISTS_UPDATE_EVENT);
     }

From 347ffa1af62ea9d3376582f263cf452372e8efdc Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 17 Aug 2022 11:00:54 +0100
Subject: [PATCH 53/81] Reinstate the skeleton UI when the list is loading

---
 src/components/views/rooms/RoomSublist.tsx   | 20 ++++++++++++---
 src/stores/room-list/Interface.ts            |  3 +++
 src/stores/room-list/RoomListStore.ts        |  1 +
 src/stores/room-list/SlidingRoomListStore.ts | 27 +++++++++++++-------
 4 files changed, 38 insertions(+), 13 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 391cee4db94..567cfe57f6b 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -39,7 +39,7 @@ import { ListAlgorithm, SortAlgorithm } from "../../../stores/room-list/algorith
 import { ListLayout } from "../../../stores/room-list/ListLayout";
 import { DefaultTagID, TagID } from "../../../stores/room-list/models";
 import RoomListLayoutStore from "../../../stores/room-list/RoomListLayoutStore";
-import RoomListStore, { LISTS_UPDATE_EVENT } from "../../../stores/room-list/RoomListStore";
+import RoomListStore, { LISTS_UPDATE_EVENT, LISTS_LOADING_EVENT } from "../../../stores/room-list/RoomListStore";
 import { arrayFastClone, arrayHasOrderChange } from "../../../utils/arrays";
 import { objectExcluding, objectHasDiff } from "../../../utils/objects";
 import ResizeNotifier from "../../../utils/ResizeNotifier";
@@ -101,7 +101,7 @@ interface IState {
     height: number;
     rooms: Room[];
     filteredExtraTiles?: ReactComponentElement<typeof ExtraTile>[];
-    slidingSyncLoading: boolean;
+    roomsLoading: boolean;
 }
 
 export default class RoomSublist extends React.Component<IProps, IState> {
@@ -131,7 +131,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             rooms: (
                 arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || [])
             ),
-            slidingSyncLoading: false,
+            roomsLoading: false,
         };
         // Why Object.assign() and not this.state.height? Because TypeScript says no.
         this.state = Object.assign(this.state, { height: this.calculateInitialHeight() });
@@ -253,6 +253,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     public async componentDidMount() {
         this.dispatcherRef = defaultDispatcher.register(this.onAction);
         RoomListStore.instance.on(LISTS_UPDATE_EVENT, this.onListsUpdated);
+        RoomListStore.instance.on(LISTS_LOADING_EVENT, this.onListsLoading);
 
         // Using the passive option to not block the main thread
         // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#improving_scrolling_performance_with_passive_listeners
@@ -262,9 +263,20 @@ export default class RoomSublist extends React.Component<IProps, IState> {
     public componentWillUnmount() {
         defaultDispatcher.unregister(this.dispatcherRef);
         RoomListStore.instance.off(LISTS_UPDATE_EVENT, this.onListsUpdated);
+        RoomListStore.instance.off(LISTS_LOADING_EVENT, this.onListsLoading);
         this.tilesRef.current?.removeEventListener("scroll", this.onScrollPrevent);
     }
 
+    private onListsLoading = (tagId: TagID, isLoading: boolean) => {
+        if (this.props.tagId !== tagId) {
+            return;
+        }
+        console.log("sliding onListsLoading ", tagId, isLoading);
+        this.setState({
+            roomsLoading: isLoading,
+        });
+    }
+
     private onListsUpdated = () => {
         const stateUpdates: IState & any = {}; // &any is to avoid a cast on the initializer
 
@@ -750,7 +762,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         });
 
         let content = null;
-        if (this.state.slidingSyncLoading) {
+        if (this.state.roomsLoading) {
             content = <div className="mx_RoomSublist_skeletonUI" />;
         } else if (visibleTiles.length > 0 && this.props.forceExpanded) {
             content = <div className="mx_RoomSublist_resizeBox mx_RoomSublist_resizeBox_forceExpanded">
diff --git a/src/stores/room-list/Interface.ts b/src/stores/room-list/Interface.ts
index 70e21ae7e69..55de9dd3ad2 100644
--- a/src/stores/room-list/Interface.ts
+++ b/src/stores/room-list/Interface.ts
@@ -23,6 +23,9 @@ import { IFilterCondition } from "./filters/IFilterCondition";
 export enum RoomListStoreEvent {
     // The event/channel which is called when the room lists have been changed.
     ListsUpdate = "lists_update",
+    // The event which is called when the room list is loading.
+    // Called with the (tagId, bool) which is true when the list is loading, else false.
+    ListsLoading = "lists_loading",
 }
 
 export interface RoomListStore extends EventEmitter {
diff --git a/src/stores/room-list/RoomListStore.ts b/src/stores/room-list/RoomListStore.ts
index 41115dc0abf..793dfd3f5a5 100644
--- a/src/stores/room-list/RoomListStore.ts
+++ b/src/stores/room-list/RoomListStore.ts
@@ -45,6 +45,7 @@ interface IState {
 }
 
 export const LISTS_UPDATE_EVENT = RoomListStoreEvent.ListsUpdate;
+export const LISTS_LOADING_EVENT = RoomListStoreEvent.ListsLoading; // unused; used by SlidingRoomListStore
 
 export class RoomListStoreClass extends AsyncStoreWithClient<IState> implements Interface {
     /**
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index 600b4cc2de7..49ff9158ece 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -27,6 +27,7 @@ import { SlidingSyncManager } from "../../SlidingSyncManager";
 import { MSC3575Filter, SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import SpaceStore from "../spaces/SpaceStore";
 import { MetaSpace, SpaceKey, UPDATE_SELECTED_SPACE } from "../spaces";
+import { LISTS_LOADING_EVENT } from "./RoomListStore";
 
 interface IState {
     // state is tracked in underlying classes
@@ -249,10 +250,12 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
             }
             const sort = SortAlgorithm.Recent; // default to recency sort, TODO: read from config
             this.tagIdToSortAlgo[tagId] = sort;
-            // don't bother waiting, it'll happen eventually and then we'll update it via callbacks on slidingSync
+            this.emit(LISTS_LOADING_EVENT, tagId, true);
             SlidingSyncManager.instance.ensureListRegistered(SlidingSyncManager.instance.getOrAllocateListIndex(tagId), {
                 filters: filter,
                 sort: SlidingSyncSortToFilter[sort],
+            }).then(() => {
+                this.emit(LISTS_LOADING_EVENT, tagId, false);
             });
         });
     }
@@ -260,15 +263,21 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     private onSelectedSpaceUpdated = (activeSpace: SpaceKey, allRoomsInHome: boolean) => {
         console.log("SlidingRoomListStore.onSelectedSpaceUpdated", activeSpace);
         // update the untagged filter
-        const tagID = DefaultTagID.Untagged;
-        const filters = filterConditions[tagID];
+        const tagId = DefaultTagID.Untagged;
+        const filters = filterConditions[tagId];
+        const oldSpace = filters.spaces?.[0];
         filters.spaces = (activeSpace && activeSpace != MetaSpace.Home) ? [activeSpace] : undefined;
-        SlidingSyncManager.instance.ensureListRegistered(
-            SlidingSyncManager.instance.getOrAllocateListIndex(tagID),
-            {
-                filters: filters,
-            },
-        );
+        if (oldSpace !== activeSpace) {
+            this.emit(LISTS_LOADING_EVENT, tagId, true);
+            SlidingSyncManager.instance.ensureListRegistered(
+                SlidingSyncManager.instance.getOrAllocateListIndex(tagId),
+                {
+                    filters: filters,
+                },
+            ).then(() => {
+                this.emit(LISTS_LOADING_EVENT, tagId, false);
+            });
+        }
     }
 
 

From 5e976fae2cde0474daa698e56f48f7fc37663981 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 17 Aug 2022 11:08:19 +0100
Subject: [PATCH 54/81] linting

---
 src/SlidingSyncManager.ts                    |  8 ++++----
 src/components/views/rooms/RoomSublist.tsx   |  2 +-
 src/stores/RoomViewStore.tsx                 |  1 -
 src/stores/room-list/SlidingRoomListStore.ts | 21 ++++++++++----------
 4 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index a7e1a3e3a85..8dde2d70656 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -79,12 +79,12 @@ export class SlidingSyncManager {
 
     public slidingSync: SlidingSync;
     private client: MatrixClient;
-    private listIdToIndex: Record<string,number>;
+    private listIdToIndex: Record<string, number>;
 
     private configurePromise: Promise<void>;
     private configureResolve: Function;
 
-    constructor(){
+    constructor() {
         this.listIdToIndex = {};
         this.configurePromise = new Promise((resolve) => {
             this.configureResolve = resolve;
@@ -120,8 +120,8 @@ export class SlidingSyncManager {
                 [EventType.RoomMember, this.client.getUserId()], // lets the client calculate that we are in fact in the room
             ],
             filters: {
-              room_types: ["m.space"],
-            }
+                room_types: ["m.space"],
+            },
         });
         this.configureResolve();
         return this.slidingSync;
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 567cfe57f6b..434580679a9 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -275,7 +275,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         this.setState({
             roomsLoading: isLoading,
         });
-    }
+    };
 
     private onListsUpdated = () => {
         const stateUpdates: IState & any = {}; // &any is to avoid a cast on the initializer
diff --git a/src/stores/RoomViewStore.tsx b/src/stores/RoomViewStore.tsx
index b153e333335..bc682643737 100644
--- a/src/stores/RoomViewStore.tsx
+++ b/src/stores/RoomViewStore.tsx
@@ -318,7 +318,6 @@ export class RoomViewStore extends Store<ActionPayload> {
                 return;
             }
 
-
             const newState = {
                 roomId: payload.room_id,
                 roomAlias: payload.room_alias,
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index 49ff9158ece..c43b4ea8384 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -16,6 +16,8 @@ limitations under the License.
 
 import { Room } from "matrix-js-sdk/src/models/room";
 import { logger } from "matrix-js-sdk/src/logger";
+import { MSC3575Filter, SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
+
 import { RoomUpdateCause, TagID, OrderedDefaultTagIDs, DefaultTagID } from "./models";
 import { ITagMap, ListAlgorithm, SortAlgorithm } from "./algorithms/models";
 import { ActionPayload } from "../../dispatcher/payloads";
@@ -24,7 +26,6 @@ import { IFilterCondition } from "./filters/IFilterCondition";
 import { AsyncStoreWithClient } from "../AsyncStoreWithClient";
 import { RoomListStore as Interface, RoomListStoreEvent } from "./Interface";
 import { SlidingSyncManager } from "../../SlidingSyncManager";
-import { MSC3575Filter, SlidingSyncEvent } from "matrix-js-sdk/src/sliding-sync";
 import SpaceStore from "../spaces/SpaceStore";
 import { MetaSpace, SpaceKey, UPDATE_SELECTED_SPACE } from "../spaces";
 import { LISTS_LOADING_EVENT } from "./RoomListStore";
@@ -68,7 +69,7 @@ const filterConditions: Record<TagID, MSC3575Filter> = {
 export const LISTS_UPDATE_EVENT = RoomListStoreEvent.ListsUpdate;
 
 export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> implements Interface {
-    private tagIdToSortAlgo: Record<TagID,SortAlgorithm> = {};
+    private tagIdToSortAlgo: Record<TagID, SortAlgorithm> = {};
     private tagMap: ITagMap = {};
     private counts: Record<TagID, number> = {};
 
@@ -117,12 +118,10 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         return this.counts[tagId] || 0;
     }
 
-
     public setListOrder(tagId: TagID, order: ListAlgorithm) {
         // TODO?
     }
 
-
     public getListOrder(tagId: TagID): ListAlgorithm {
         // TODO: handle unread msgs first?
         return ListAlgorithm.Natural;
@@ -160,10 +159,10 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     public getTagsForRoom(room: Room): TagID[] {
         // check all lists for each tag we know about and see if the room is there
         const tags = [];
-        for (let tagId in this.tagIdToSortAlgo) {
+        for (const tagId in this.tagIdToSortAlgo) {
             const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
-            let { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(index);
-            for (let roomIndex in roomIndexToRoomId) {
+            const { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(index);
+            for (const roomIndex in roomIndexToRoomId) {
                 const roomId = roomIndexToRoomId[roomIndex];
                 if (roomId === room.roomId) {
                     tags.push(tagId);
@@ -217,7 +216,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         // now set the rooms
         const rooms = orderedRoomIds.map((roomId) => {
             return this.matrixClient.getRoom(roomId);
-        })
+        });
         tagMap[tagId] = rooms;
         this.tagMap = tagMap;
     }
@@ -251,7 +250,8 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
             const sort = SortAlgorithm.Recent; // default to recency sort, TODO: read from config
             this.tagIdToSortAlgo[tagId] = sort;
             this.emit(LISTS_LOADING_EVENT, tagId, true);
-            SlidingSyncManager.instance.ensureListRegistered(SlidingSyncManager.instance.getOrAllocateListIndex(tagId), {
+            const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
+            SlidingSyncManager.instance.ensureListRegistered(index, {
                 filters: filter,
                 sort: SlidingSyncSortToFilter[sort],
             }).then(() => {
@@ -278,8 +278,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
                 this.emit(LISTS_LOADING_EVENT, tagId, false);
             });
         }
-    }
-
+    };
 
     // Intended for test usage
     public async resetStore() {

From 328713cfe3a287b4de1fe68149714889fb60b85d Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 18 Aug 2022 17:46:36 +0100
Subject: [PATCH 55/81] Add support for sticky rooms based on the currently
 active room

---
 src/stores/room-list/SlidingRoomListStore.ts | 75 +++++++++++++++++++-
 1 file changed, 73 insertions(+), 2 deletions(-)

diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index c43b4ea8384..e6e8803dc99 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -29,6 +29,7 @@ import { SlidingSyncManager } from "../../SlidingSyncManager";
 import SpaceStore from "../spaces/SpaceStore";
 import { MetaSpace, SpaceKey, UPDATE_SELECTED_SPACE } from "../spaces";
 import { LISTS_LOADING_EVENT } from "./RoomListStore";
+import { RoomViewStore } from "../RoomViewStore";
 
 interface IState {
     // state is tracked in underlying classes
@@ -72,6 +73,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     private tagIdToSortAlgo: Record<TagID, SortAlgorithm> = {};
     private tagMap: ITagMap = {};
     private counts: Record<TagID, number> = {};
+    private stickyRoomId: string | null;
 
     constructor() {
         super(defaultDispatcher);
@@ -191,6 +193,15 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
 
     private refreshOrderedLists(tagId: string, roomIndexToRoomId: Record<number, string>): void {
         const tagMap = this.tagMap;
+
+        // this room will not move due to it being viewed: it is sticky. This can be null to indicate
+        // no sticky room if you aren't viewing a room.
+        this.stickyRoomId = RoomViewStore.instance.getRoomId();
+        let stickyRoomNewIndex = -1;
+        let stickyRoomOldIndex = (tagMap[tagId] || []).findIndex((room) => {
+            return room.roomId === this.stickyRoomId;
+        });
+
         // order from low to high
         const orderedRoomIndexes = Object.keys(roomIndexToRoomId).map((numStr) => {
             return Number(numStr);
@@ -207,12 +218,32 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
             if (!rid) {
                 throw new Error("index " + i + " has no room ID: Map => " + JSON.stringify(roomIndexToRoomId));
             }
+            if (rid === this.stickyRoomId) {
+                stickyRoomNewIndex = i;
+            }
             return rid;
         });
         logger.debug(
-            "SlidingRoomListStore.refreshOrderedLists ", tagId, " rooms:",
+            `SlidingRoomListStore.refreshOrderedLists ${tagId} sticky: ${this.stickyRoomId}`,
+            `${stickyRoomOldIndex} -> ${stickyRoomNewIndex}`,
+            "rooms:",
             orderedRoomIds.length < 30 ? orderedRoomIds : orderedRoomIds.length,
         );
+
+        if (this.stickyRoomId && stickyRoomOldIndex >= 0 && stickyRoomNewIndex >= 0) {
+            // this update will move this sticky room from old to new, which we do not want.
+            // Instead, keep the sticky room ID index position as it is, swap it with
+            // whatever was in its place.
+            // Some scenarios with sticky room S and bump room B (other letters unimportant):
+            // A, S, C, B                                  S, A, B
+            // B, A, S, C  <---- without sticky rooms ---> B, S, A
+            // B, S, A, C  <- with sticky rooms applied -> S, B, A
+            // In other words, we need to swap positions to keep it locked in place.
+            const inWayRoomId = orderedRoomIds[stickyRoomOldIndex];
+            orderedRoomIds[stickyRoomOldIndex] = this.stickyRoomId;
+            orderedRoomIds[stickyRoomNewIndex] = inWayRoomId;
+        }
+
         // now set the rooms
         const rooms = orderedRoomIds.map((roomId) => {
             return this.matrixClient.getRoom(roomId);
@@ -229,10 +260,50 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         this.emit(LISTS_UPDATE_EVENT);
     }
 
+    private onRoomViewStoreUpdated() {
+        // we only care about this to know when the user has clicked on a room to set the stickiness value
+        if (RoomViewStore.instance.getRoomId() === this.stickyRoomId) {
+            return;
+        }
+
+        let hasUpdatedAnyList = false;
+
+        // every list with the OLD sticky room ID needs to be resorted because it now needs to take
+        // its proper place as it is no longer sticky. The newly sticky room can remain the same though,
+        // as we only actually care about its sticky status when we get list updates.
+        const oldStickyRoom = this.stickyRoomId;
+        // it's not safe to check the data in slidingSync as it is tracking the server's view of the
+        // room list. There's an edge case whereby the sticky room has gone outside the window and so
+        // would not be present in the roomIndexToRoomId map anymore, and hence clicking away from it
+        // will make it disappear eventually. We need to check orderedLists as that is the actual
+        // sorted renderable list of rooms which sticky rooms apply to.
+        for (const tagId in this.orderedLists) {
+            const list = this.orderedLists[tagId];
+            const room = list.find((room) => {
+                return room.roomId === oldStickyRoom;
+            });
+            if (room) {
+                // resort it based on the slidingSync view of the list. This may cause this old sticky
+                // room to cease to exist.
+                const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
+                const {roomIndexToRoomId} = SlidingSyncManager.instance.slidingSync.getListData(index);
+                this.refreshOrderedLists(tagId, roomIndexToRoomId);
+                hasUpdatedAnyList = true;
+            }
+        }
+        // in the event we didn't call refreshOrderedLists, it helps to still remember the sticky room ID.
+        this.stickyRoomId = RoomViewStore.instance.getRoomId();
+
+        if (hasUpdatedAnyList) {
+            this.emit(LISTS_UPDATE_EVENT);
+        }
+    }
+
     protected async onReady(): Promise<any> {
         console.log("SlidingRoomListStore.onReady");
-        // permanent listener, we never get destroyed. Could be an issue if we want to test this in isolation.
+        // permanent listeners: never get destroyed. Could be an issue if we want to test this in isolation.
         SlidingSyncManager.instance.slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate.bind(this));
+        RoomViewStore.instance.addListener(this.onRoomViewStoreUpdated.bind(this));
         SpaceStore.instance.on(UPDATE_SELECTED_SPACE, this.onSelectedSpaceUpdated.bind(this));
         if (SpaceStore.instance.activeSpace) {
             this.onSelectedSpaceUpdated(SpaceStore.instance.activeSpace, false);

From c545b358efd5732d453fefd90a405cb5e180d944 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 18 Aug 2022 19:24:01 +0100
Subject: [PATCH 56/81] Add a bunch of passing SS E2E tests; some WIP

---
 cypress/e2e/sliding-sync/sliding-sync.ts | 171 ++++++++++++++++++++++-
 1 file changed, 167 insertions(+), 4 deletions(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index 41bdb6b22ac..e28095c6c3e 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -20,6 +20,8 @@ import { SynapseInstance } from "../../plugins/synapsedocker";
 import { SettingLevel } from "../../../src/settings/SettingLevel";
 import { Layout } from "../../../src/settings/enums/Layout";
 import { ProxyInstance } from "../../plugins/sliding-sync";
+import _ from "lodash";
+import { createClient, MatrixClient } from "matrix-js-sdk";
 
 describe("Sliding Sync", () => {
     beforeEach(() => {
@@ -55,6 +57,46 @@ describe("Sliding Sync", () => {
         cy.get<ProxyInstance>("@proxy").then(cy.stopProxy);
     });
 
+    // assert order
+    const checkOrder = (wantOrder: string[]) => {
+        cy.contains(".mx_RoomSublist", "Rooms").find(".mx_RoomTile_title").should((elements) => {
+            expect(_.map(elements, (e) => {
+                return e.textContent;
+            }), "rooms are sorted").to.deep.equal(wantOrder);
+        });
+    };
+    const bumpRoom = (alias: string) => {
+        // Send a message into the given room, this should bump the room to the top
+        cy.get<string>(alias).then((roomId) => {
+            return cy.sendEvent(roomId, null, "m.room.message", {
+                body: "Hello world",
+                msgtype: "m.text",
+            });
+        });
+    }
+    const createAndJoinBob = () => {
+        // create a Bob user
+        let baseUrl;
+        cy.get<SynapseInstance>("@synapse").then((synapse) => {
+            baseUrl = synapse.baseUrl;
+            return cy.registerUser(synapse, "bob", "passwordgoeshere123", "Bob");
+        }).then((creds) => {
+            return createClient({
+                baseUrl: baseUrl,
+                accessToken: creds.accessToken,
+                userId: creds.userId,
+                deviceId: creds.deviceId,
+            });
+        }).as("bob");
+
+        // invite Bob to Test Room and accept then send a message.
+        cy.all([cy.get<string>("@roomId"), cy.get<MatrixClient>("@bob")]).then(([roomId, bob]) => {
+            return cy.inviteUser(roomId, bob.getUserId()).then(() => {
+                return bob.joinRoom(roomId);
+            });
+        });
+    }
+
     // sanity check everything works
     it("should correctly render expected messages", () => {
         cy.get<string>("@roomId").then(roomId => cy.visit("/#/room/" + roomId));
@@ -70,12 +112,133 @@ describe("Sliding Sync", () => {
         cy.get(".mx_GenericEventListSummary_toggle[aria-expanded=false]").click();
     });
 
-    it.only("should render rooms in reverse chronological order", () => {
+    it("should render the Rooms list in reverse chronological order by default and allowing sorting A-Z", () => {
         // create rooms and check room names are correct
-        cy.createRoom({ name: "Apple" }).as("roomApple").then(()=>cy.contains(".mx_RoomSublist", "Apple"));
-        cy.createRoom({ name: "Pineapple" }).as("roomPineapple").then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
-        cy.createRoom({ name: "Orange" }).as("roomOrange").then(()=>cy.contains(".mx_RoomSublist", "Orange"));
+        cy.createRoom({ name: "Apple" }).then(()=>cy.contains(".mx_RoomSublist", "Apple"));
+        cy.createRoom({ name: "Pineapple" }).then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
+        cy.createRoom({ name: "Orange" }).then(()=>cy.contains(".mx_RoomSublist", "Orange"));
         // check the rooms are in the right order
         cy.get(".mx_RoomTile").should('have.length', 4); // due to the Test Room in beforeEach
+        checkOrder([
+            "Orange", "Pineapple", "Apple", "Test Room",
+        ]);
+
+        cy.contains(".mx_RoomSublist", "Rooms").find(".mx_RoomSublist_menuButton").click({force: true});
+        cy.contains("A-Z").click();
+        cy.get('.mx_StyledRadioButton_checked').should("contain.text", "A-Z");
+        checkOrder([
+            "Apple", "Orange", "Pineapple", "Test Room",
+        ]);
+    });
+
+    it("should move rooms around as new events arrive", () => {
+        // create rooms and check room names are correct
+        cy.createRoom({ name: "Apple" }).as("roomA").then(()=>cy.contains(".mx_RoomSublist", "Apple"));
+        cy.createRoom({ name: "Pineapple" }).as("roomP").then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
+        cy.createRoom({ name: "Orange" }).as("roomO").then(()=>cy.contains(".mx_RoomSublist", "Orange"));
+
+        // Select the Test Room
+        cy.contains(".mx_RoomTile", "Test Room").click();
+
+        checkOrder([
+            "Orange", "Pineapple", "Apple", "Test Room",
+        ]);
+        bumpRoom("@roomA");
+        checkOrder([
+            "Apple", "Orange", "Pineapple", "Test Room",
+        ]);
+        bumpRoom("@roomO");
+        checkOrder([
+            "Orange", "Apple", "Pineapple", "Test Room",
+        ]);
+        bumpRoom("@roomO");
+        checkOrder([
+            "Orange", "Apple", "Pineapple", "Test Room",
+        ]);
+        bumpRoom("@roomP");
+        checkOrder([
+            "Pineapple", "Orange", "Apple", "Test Room",
+        ]);
+    });
+
+    it("should not move the selected room: it should be sticky", () => {
+        // create rooms and check room names are correct
+        cy.createRoom({ name: "Apple" }).as("roomA").then(()=>cy.contains(".mx_RoomSublist", "Apple"));
+        cy.createRoom({ name: "Pineapple" }).as("roomP").then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
+        cy.createRoom({ name: "Orange" }).as("roomO").then(()=>cy.contains(".mx_RoomSublist", "Orange"));
+
+        // Given a list of Orange, Pineapple, Apple - if Pineapple is active and a message is sent in Apple, the list should
+        // turn into Apple, Pineapple, Orange - the index position of Pineapple never changes even though the list should technically
+        // be Apple, Orange Pineapple - only when you click on a different room do things reshuffle.
+
+        // Select the Pineapple room
+        cy.contains(".mx_RoomTile", "Pineapple").click();
+        checkOrder([
+            "Orange", "Pineapple", "Apple", "Test Room",
+        ]);
+
+        // Move Apple
+        bumpRoom("@roomA");
+        checkOrder([
+            "Apple", "Pineapple", "Orange", "Test Room",
+        ]);
+
+        // Select the Test Room
+        cy.contains(".mx_RoomTile", "Test Room").click();
+
+        // the rooms reshuffle to match reality
+        checkOrder([
+            "Apple", "Orange", "Pineapple", "Test Room",
+        ]);
+    });
+
+    it.only("should show the right unread notifications", () => {
+        createAndJoinBob();
+
+        // send a message in the test room: unread notif count shoould increment
+        cy.all([cy.get<string>("@roomId"), cy.get<MatrixClient>("@bob")]).then(([roomId, bob]) => {
+            return bob.sendTextMessage(roomId, "Hello World");
+        });
+
+        // check that there is an unread notification (grey) as 1
+        cy.contains(".mx_RoomTile", "Test Room").contains(".mx_NotificationBadge_count", "1");
+        cy.get(".mx_NotificationBadge").should("not.have.class", "mx_NotificationBadge_highlighted");
+        
+        // send an @mention: highlight count (red) should be 2.
+        cy.all([cy.get<string>("@roomId"), cy.get<MatrixClient>("@bob")]).then(([roomId, bob]) => {
+            return bob.sendTextMessage(roomId, "Hello Sloth");
+        });
+        cy.contains(".mx_RoomTile", "Test Room").contains(".mx_NotificationBadge_count", "2");
+        cy.get(".mx_NotificationBadge").should("have.class", "mx_NotificationBadge_highlighted");
+
+        // click on the room, the notif counts should disappear
+        cy.contains(".mx_RoomTile", "Test Room").click();
+        cy.contains(".mx_RoomTile", "Test Room").should("not.have.class", "mx_NotificationBadge_count");
+    });
+
+    it("should not show unread indicators", () => {
+        createAndJoinBob();
+
+        // disable notifs in this room (TODO: CS API call?)
+        cy.contains(".mx_RoomTile", "Test Room").find(".mx_RoomTile_notificationsButton").click({force: true});
+        cy.contains("None").click();
+
+        // create a new room so we know when the message has been received as it'll re-shuffle the room list
+        cy.createRoom({
+            name: "Dummy",
+        });
+        checkOrder([
+            "Dummy", "Test Room",
+        ]);
+
+        cy.all([cy.get<string>("@roomId"), cy.get<MatrixClient>("@bob")]).then(([roomId, bob]) => {
+            return bob.sendTextMessage(roomId, "Do you read me?");
+        });
+        // wait for this message to arrive, tell by the room list resorting
+        checkOrder([
+            "Test Room", "Dummy",
+        ]);
+
+        cy.contains(".mx_RoomTile", "Test Room").find(".mx_NotificationBadge").should("not.have.class", "mx_NotificationBadge_dot");
     });
 });

From d0e60ebfa68fa24788ab23b85c0d1135591d67b5 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 18 Aug 2022 19:26:39 +0100
Subject: [PATCH 57/81] Unbreak build from git merge

---
 src/components/views/dialogs/spotlight/SpotlightDialog.tsx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
index e083aa358c7..f5858db4bd2 100644
--- a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
+++ b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
@@ -356,6 +356,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
         () => {
             const userResults = [];
             let roomResults;
+            let alreadyAddedUserIds;
             if (isSlidingSyncEnabled) {
                 // use the rooms sliding sync returned as the server has already worked it out for us
                 roomResults = slidingSyncRooms.map(toRoomResult);
@@ -363,7 +364,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
                 roomResults = findVisibleRooms(cli).map(toRoomResult);
                 // If we already have a DM with the user we're looking for, we will
                 // show that DM instead of the user themselves
-                const alreadyAddedUserIds = roomResults.reduce((userIds, result) => {
+                alreadyAddedUserIds = roomResults.reduce((userIds, result) => {
                     const userId = DMRoomMap.shared().getUserIdForRoomId(result.room.roomId);
                     if (!userId) return userIds;
                     if (result.room.getJoinedMemberCount() > 2) return userIds;

From ee42af180379b2e491a458381b14c75a7c8e155b Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 18 Aug 2022 19:47:09 +0100
Subject: [PATCH 58/81] Suppress unread indicators in sliding sync mode

---
 cypress/e2e/sliding-sync/sliding-sync.ts | 6 +++---
 src/Unread.ts                            | 5 +++++
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index e28095c6c3e..d132f383bc9 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -192,7 +192,7 @@ describe("Sliding Sync", () => {
         ]);
     });
 
-    it.only("should show the right unread notifications", () => {
+    it("should show the right unread notifications", () => {
         createAndJoinBob();
 
         // send a message in the test room: unread notif count shoould increment
@@ -216,7 +216,7 @@ describe("Sliding Sync", () => {
         cy.contains(".mx_RoomTile", "Test Room").should("not.have.class", "mx_NotificationBadge_count");
     });
 
-    it("should not show unread indicators", () => {
+    it.only("should not show unread indicators", () => { // TODO: for now. Later we should.
         createAndJoinBob();
 
         // disable notifs in this room (TODO: CS API call?)
@@ -239,6 +239,6 @@ describe("Sliding Sync", () => {
             "Test Room", "Dummy",
         ]);
 
-        cy.contains(".mx_RoomTile", "Test Room").find(".mx_NotificationBadge").should("not.have.class", "mx_NotificationBadge_dot");
+        cy.contains(".mx_RoomTile", "Test Room").get(".mx_NotificationBadge").should("not.exist");
     });
 });
diff --git a/src/Unread.ts b/src/Unread.ts
index 19dc07f4141..4eb178c4f61 100644
--- a/src/Unread.ts
+++ b/src/Unread.ts
@@ -55,6 +55,11 @@ export function eventTriggersUnreadCount(ev: MatrixEvent): boolean {
 }
 
 export function doesRoomHaveUnreadMessages(room: Room): boolean {
+    if (SettingsStore.getValue("feature_sliding_sync")) {
+        // Sliding Sync doesn't support unread indicator dots (yet...)
+        return false;
+    }
+
     const myUserId = MatrixClientPeg.get().getUserId();
 
     // get the most recent read receipt sent by our account.

From 43ba62509e665b0836364e57ed81032f1062eba8 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 19 Aug 2022 11:06:55 +0100
Subject: [PATCH 59/81] Add regression test for
 https://github.com/matrix-org/sliding-sync/issues/28

---
 cypress/e2e/sliding-sync/sliding-sync.ts | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index d132f383bc9..60a9634eafb 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -216,7 +216,7 @@ describe("Sliding Sync", () => {
         cy.contains(".mx_RoomTile", "Test Room").should("not.have.class", "mx_NotificationBadge_count");
     });
 
-    it.only("should not show unread indicators", () => { // TODO: for now. Later we should.
+    it("should not show unread indicators", () => { // TODO: for now. Later we should.
         createAndJoinBob();
 
         // disable notifs in this room (TODO: CS API call?)
@@ -241,4 +241,15 @@ describe("Sliding Sync", () => {
 
         cy.contains(".mx_RoomTile", "Test Room").get(".mx_NotificationBadge").should("not.exist");
     });
+
+    it.only("should update user settings promptly", () => {
+        cy.get(".mx_UserMenu_userAvatar").click();
+        cy.contains("All settings").click();
+        cy.contains("Preferences").click();
+        cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format").should("exist").find(".mx_ToggleSwitch_on").should("not.exist");
+        cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format").should("exist").find(".mx_ToggleSwitch_ball").click();
+        cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format", { timeout: 2000 }).should("exist").find(
+            ".mx_ToggleSwitch_on", { timeout: 2000 },
+        ).should("exist");
+    });
 });

From 7a6b7548cdf21c9793e2b01b1228b58e2c8bdb6f Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Fri, 19 Aug 2022 19:26:59 +0100
Subject: [PATCH 60/81] Add invite test flows; show the invite list

The refactor to SS RLS removed the invite list entirely.
---
 cypress/e2e/sliding-sync/sliding-sync.ts | 71 +++++++++++++++++++++++-
 cypress/plugins/sliding-sync/index.ts    |  2 +-
 src/components/views/rooms/RoomList.tsx  |  4 +-
 3 files changed, 73 insertions(+), 4 deletions(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index 60a9634eafb..446f9037b78 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -242,7 +242,7 @@ describe("Sliding Sync", () => {
         cy.contains(".mx_RoomTile", "Test Room").get(".mx_NotificationBadge").should("not.exist");
     });
 
-    it.only("should update user settings promptly", () => {
+    it("should update user settings promptly", () => {
         cy.get(".mx_UserMenu_userAvatar").click();
         cy.contains("All settings").click();
         cy.contains("Preferences").click();
@@ -252,4 +252,73 @@ describe("Sliding Sync", () => {
             ".mx_ToggleSwitch_on", { timeout: 2000 },
         ).should("exist");
     });
+
+    it.only("should show and be able to accept/reject/rescind invites", () => {
+        createAndJoinBob();
+
+        let clientUserId;
+        cy.getClient().then((cli) => {
+            clientUserId = cli.getUserId();
+        });
+
+        // invite Sloth into 3 rooms:
+        // - roomJoin: will join this room
+        // - roomReject: will reject the invite
+        // - roomRescind: will make Bob rescind the invite
+        let roomJoin, roomReject, roomRescind, bobClient;
+        cy.get<MatrixClient>("@bob").then((bob) => {
+            bobClient = bob;
+            return Promise.all([
+                bob.createRoom({name: "Join"}),
+                bob.createRoom({name: "Reject"}),
+                bob.createRoom({name: "Rescind"}),
+            ]);
+        }).then(([join,reject,rescind]) => {
+            roomJoin = join.room_id;
+            roomReject = reject.room_id;
+            roomRescind = rescind.room_id;
+            return Promise.all([
+                bobClient.invite(roomJoin, clientUserId),
+                bobClient.invite(roomReject, clientUserId),
+                bobClient.invite(roomRescind, clientUserId),
+            ])
+        });
+
+        // wait for them all to be on the UI
+        cy.get(".mx_RoomTile").should('have.length', 4); // due to the Test Room in beforeEach
+
+        cy.contains(".mx_RoomTile", "Join").click();
+        cy.contains(".mx_AccessibleButton","Accept").click();
+
+        checkOrder([
+            "Join", "Test Room",
+        ]);
+
+        cy.contains(".mx_RoomTile", "Reject").click();
+        cy.get(".mx_RoomView").contains(".mx_AccessibleButton", "Reject").click();
+
+        // wait for the rejected room to disappear
+        cy.get(".mx_RoomTile").should('have.length', 3);
+
+        // check the lists are correct
+        checkOrder([
+            "Join", "Test Room",
+        ]);
+        cy.contains(".mx_RoomSublist", "Invites").find(".mx_RoomTile_title").should((elements) => {
+            expect(_.map(elements, (e) => {
+                return e.textContent;
+            }), "rooms are sorted").to.deep.equal(["Rescind"]);
+        });
+
+        // now rescind the invite
+        cy.get<MatrixClient>("@bob").then((bob) => {
+            return bob.kick(roomRescind, clientUserId);
+        });
+        cy.contains(".mx_RoomSublist_showNButtonText", "Show").click(); // sometimes the room list gets hidden :S FIXME
+        // wait for the rescind to take effect and check the joined list once more
+        cy.get(".mx_RoomTile").should('have.length', 2);
+        checkOrder([
+            "Join", "Test Room",
+        ]);
+    });
 });
diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index f5dca703173..0969a5ea523 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -77,7 +77,7 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
     const port = await getFreePort();
     console.log(new Date(),"starting proxy container...");
     const containerId = await dockerRun({
-        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.3.0",
+        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.3.3",
         containerName: "react-sdk-cypress-sliding-sync-proxy",
         params: [
             "--rm",
diff --git a/src/components/views/rooms/RoomList.tsx b/src/components/views/rooms/RoomList.tsx
index 226c6118586..b2493db25cc 100644
--- a/src/components/views/rooms/RoomList.tsx
+++ b/src/components/views/rooms/RoomList.tsx
@@ -462,7 +462,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
     private getRoomDelta = (roomId: string, delta: number, unread = false) => {
         const lists = RoomListStore.instance.orderedLists;
         const rooms: Room[] = [];
-        ALWAYS_VISIBLE_TAGS.forEach(t => { // FIXME: read from store?
+        TAG_ORDER.forEach(t => {
             let listRooms = lists[t];
 
             if (unread) {
@@ -587,7 +587,7 @@ export default class RoomList extends React.PureComponent<IProps, IState> {
         const showSkeleton = !this.state.suggestedRooms?.length &&
             Object.values(RoomListStore.instance.orderedLists).every(list => !list?.length);
 
-        return ALWAYS_VISIBLE_TAGS // FIXME: read from store?
+        return TAG_ORDER
             .map(orderedTagId => {
                 let extraTiles = null;
                 if (orderedTagId === DefaultTagID.Suggested) {

From f737cbfa665a56be597969f565870dc2ca9f1d3d Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 22 Aug 2022 14:45:36 +0100
Subject: [PATCH 61/81] Remove show more click as it wasn't the bug

---
 cypress/e2e/sliding-sync/sliding-sync.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index 446f9037b78..77c30c85709 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -314,7 +314,7 @@ describe("Sliding Sync", () => {
         cy.get<MatrixClient>("@bob").then((bob) => {
             return bob.kick(roomRescind, clientUserId);
         });
-        cy.contains(".mx_RoomSublist_showNButtonText", "Show").click(); // sometimes the room list gets hidden :S FIXME
+
         // wait for the rescind to take effect and check the joined list once more
         cy.get(".mx_RoomTile").should('have.length', 2);
         checkOrder([

From bd9d41c2f77e2ea8fb02f2c4806517be0cca7520 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 22 Aug 2022 16:09:02 +0100
Subject: [PATCH 62/81] Linting and i18n

---
 cypress/e2e/sliding-sync/sliding-sync.ts     | 63 +++++++++++---------
 cypress/global.d.ts                          |  2 +
 cypress/plugins/sliding-sync/index.ts        | 10 ++--
 src/i18n/strings/en_EN.json                  |  2 +-
 src/stores/room-list/SlidingRoomListStore.ts |  4 +-
 5 files changed, 45 insertions(+), 36 deletions(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index 77c30c85709..f06dd53a3ce 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -16,12 +16,13 @@ limitations under the License.
 
 /// <reference types="cypress" />
 
+import _ from "lodash";
+import { MatrixClient } from "matrix-js-sdk/src/matrix";
+
 import { SynapseInstance } from "../../plugins/synapsedocker";
 import { SettingLevel } from "../../../src/settings/SettingLevel";
 import { Layout } from "../../../src/settings/enums/Layout";
 import { ProxyInstance } from "../../plugins/sliding-sync";
-import _ from "lodash";
-import { createClient, MatrixClient } from "matrix-js-sdk";
 
 describe("Sliding Sync", () => {
     beforeEach(() => {
@@ -73,15 +74,19 @@ describe("Sliding Sync", () => {
                 msgtype: "m.text",
             });
         });
-    }
+    };
     const createAndJoinBob = () => {
         // create a Bob user
         let baseUrl;
+        let creds;
         cy.get<SynapseInstance>("@synapse").then((synapse) => {
             baseUrl = synapse.baseUrl;
             return cy.registerUser(synapse, "bob", "passwordgoeshere123", "Bob");
-        }).then((creds) => {
-            return createClient({
+        }).then((c) => {
+            creds = c;
+            return cy.window({ log: false });
+        }).then((window) => {
+            return window.matrixcs.createClient({
                 baseUrl: baseUrl,
                 accessToken: creds.accessToken,
                 userId: creds.userId,
@@ -95,7 +100,7 @@ describe("Sliding Sync", () => {
                 return bob.joinRoom(roomId);
             });
         });
-    }
+    };
 
     // sanity check everything works
     it("should correctly render expected messages", () => {
@@ -114,16 +119,16 @@ describe("Sliding Sync", () => {
 
     it("should render the Rooms list in reverse chronological order by default and allowing sorting A-Z", () => {
         // create rooms and check room names are correct
-        cy.createRoom({ name: "Apple" }).then(()=>cy.contains(".mx_RoomSublist", "Apple"));
-        cy.createRoom({ name: "Pineapple" }).then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
-        cy.createRoom({ name: "Orange" }).then(()=>cy.contains(".mx_RoomSublist", "Orange"));
+        cy.createRoom({ name: "Apple" }).then(() => cy.contains(".mx_RoomSublist", "Apple"));
+        cy.createRoom({ name: "Pineapple" }).then(() => cy.contains(".mx_RoomSublist", "Pineapple"));
+        cy.createRoom({ name: "Orange" }).then(() => cy.contains(".mx_RoomSublist", "Orange"));
         // check the rooms are in the right order
         cy.get(".mx_RoomTile").should('have.length', 4); // due to the Test Room in beforeEach
         checkOrder([
             "Orange", "Pineapple", "Apple", "Test Room",
         ]);
 
-        cy.contains(".mx_RoomSublist", "Rooms").find(".mx_RoomSublist_menuButton").click({force: true});
+        cy.contains(".mx_RoomSublist", "Rooms").find(".mx_RoomSublist_menuButton").click({ force: true });
         cy.contains("A-Z").click();
         cy.get('.mx_StyledRadioButton_checked').should("contain.text", "A-Z");
         checkOrder([
@@ -133,9 +138,9 @@ describe("Sliding Sync", () => {
 
     it("should move rooms around as new events arrive", () => {
         // create rooms and check room names are correct
-        cy.createRoom({ name: "Apple" }).as("roomA").then(()=>cy.contains(".mx_RoomSublist", "Apple"));
-        cy.createRoom({ name: "Pineapple" }).as("roomP").then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
-        cy.createRoom({ name: "Orange" }).as("roomO").then(()=>cy.contains(".mx_RoomSublist", "Orange"));
+        cy.createRoom({ name: "Apple" }).as("roomA").then(() => cy.contains(".mx_RoomSublist", "Apple"));
+        cy.createRoom({ name: "Pineapple" }).as("roomP").then(() => cy.contains(".mx_RoomSublist", "Pineapple"));
+        cy.createRoom({ name: "Orange" }).as("roomO").then(() => cy.contains(".mx_RoomSublist", "Orange"));
 
         // Select the Test Room
         cy.contains(".mx_RoomTile", "Test Room").click();
@@ -163,9 +168,9 @@ describe("Sliding Sync", () => {
 
     it("should not move the selected room: it should be sticky", () => {
         // create rooms and check room names are correct
-        cy.createRoom({ name: "Apple" }).as("roomA").then(()=>cy.contains(".mx_RoomSublist", "Apple"));
-        cy.createRoom({ name: "Pineapple" }).as("roomP").then(()=>cy.contains(".mx_RoomSublist", "Pineapple"));
-        cy.createRoom({ name: "Orange" }).as("roomO").then(()=>cy.contains(".mx_RoomSublist", "Orange"));
+        cy.createRoom({ name: "Apple" }).as("roomA").then(() => cy.contains(".mx_RoomSublist", "Apple"));
+        cy.createRoom({ name: "Pineapple" }).as("roomP").then(() => cy.contains(".mx_RoomSublist", "Pineapple"));
+        cy.createRoom({ name: "Orange" }).as("roomO").then(() => cy.contains(".mx_RoomSublist", "Orange"));
 
         // Given a list of Orange, Pineapple, Apple - if Pineapple is active and a message is sent in Apple, the list should
         // turn into Apple, Pineapple, Orange - the index position of Pineapple never changes even though the list should technically
@@ -203,7 +208,7 @@ describe("Sliding Sync", () => {
         // check that there is an unread notification (grey) as 1
         cy.contains(".mx_RoomTile", "Test Room").contains(".mx_NotificationBadge_count", "1");
         cy.get(".mx_NotificationBadge").should("not.have.class", "mx_NotificationBadge_highlighted");
-        
+
         // send an @mention: highlight count (red) should be 2.
         cy.all([cy.get<string>("@roomId"), cy.get<MatrixClient>("@bob")]).then(([roomId, bob]) => {
             return bob.sendTextMessage(roomId, "Hello Sloth");
@@ -220,7 +225,7 @@ describe("Sliding Sync", () => {
         createAndJoinBob();
 
         // disable notifs in this room (TODO: CS API call?)
-        cy.contains(".mx_RoomTile", "Test Room").find(".mx_RoomTile_notificationsButton").click({force: true});
+        cy.contains(".mx_RoomTile", "Test Room").find(".mx_RoomTile_notificationsButton").click({ force: true });
         cy.contains("None").click();
 
         // create a new room so we know when the message has been received as it'll re-shuffle the room list
@@ -246,14 +251,16 @@ describe("Sliding Sync", () => {
         cy.get(".mx_UserMenu_userAvatar").click();
         cy.contains("All settings").click();
         cy.contains("Preferences").click();
-        cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format").should("exist").find(".mx_ToggleSwitch_on").should("not.exist");
-        cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format").should("exist").find(".mx_ToggleSwitch_ball").click();
+        cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format").should("exist").find(
+            ".mx_ToggleSwitch_on").should("not.exist");
+        cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format").should("exist").find(
+            ".mx_ToggleSwitch_ball").click();
         cy.contains(".mx_SettingsFlag", "Show timestamps in 12 hour format", { timeout: 2000 }).should("exist").find(
             ".mx_ToggleSwitch_on", { timeout: 2000 },
         ).should("exist");
     });
 
-    it.only("should show and be able to accept/reject/rescind invites", () => {
+    it("should show and be able to accept/reject/rescind invites", () => {
         createAndJoinBob();
 
         let clientUserId;
@@ -265,15 +272,15 @@ describe("Sliding Sync", () => {
         // - roomJoin: will join this room
         // - roomReject: will reject the invite
         // - roomRescind: will make Bob rescind the invite
-        let roomJoin, roomReject, roomRescind, bobClient;
+        let roomJoin; let roomReject; let roomRescind; let bobClient;
         cy.get<MatrixClient>("@bob").then((bob) => {
             bobClient = bob;
             return Promise.all([
-                bob.createRoom({name: "Join"}),
-                bob.createRoom({name: "Reject"}),
-                bob.createRoom({name: "Rescind"}),
+                bob.createRoom({ name: "Join" }),
+                bob.createRoom({ name: "Reject" }),
+                bob.createRoom({ name: "Rescind" }),
             ]);
-        }).then(([join,reject,rescind]) => {
+        }).then(([join, reject, rescind]) => {
             roomJoin = join.room_id;
             roomReject = reject.room_id;
             roomRescind = rescind.room_id;
@@ -281,14 +288,14 @@ describe("Sliding Sync", () => {
                 bobClient.invite(roomJoin, clientUserId),
                 bobClient.invite(roomReject, clientUserId),
                 bobClient.invite(roomRescind, clientUserId),
-            ])
+            ]);
         });
 
         // wait for them all to be on the UI
         cy.get(".mx_RoomTile").should('have.length', 4); // due to the Test Room in beforeEach
 
         cy.contains(".mx_RoomTile", "Join").click();
-        cy.contains(".mx_AccessibleButton","Accept").click();
+        cy.contains(".mx_AccessibleButton", "Accept").click();
 
         checkOrder([
             "Join", "Test Room",
diff --git a/cypress/global.d.ts b/cypress/global.d.ts
index 18f4314d1c1..da5b3b8cd71 100644
--- a/cypress/global.d.ts
+++ b/cypress/global.d.ts
@@ -28,6 +28,7 @@ import type {
     RoomStateEvent,
     Visibility,
     RoomMemberEvent,
+    ICreateClientOpts,
 } from "matrix-js-sdk/src/matrix";
 import type { MatrixDispatcher } from "../src/dispatcher/dispatcher";
 import type PerformanceMonitor from "../src/performance";
@@ -55,6 +56,7 @@ declare global {
                 MemoryCryptoStore: typeof MemoryCryptoStore;
                 Visibility: typeof Visibility;
                 Preset: typeof Preset;
+                createClient(opts: ICreateClientOpts | string);
             };
         }
     }
diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index 0969a5ea523..8e2599bfa02 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -35,7 +35,7 @@ const instances = new Map<string, ProxyInstance>();
 const PG_PASSWORD = "p4S5w0rD";
 
 async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
-    console.log(new Date(),"Starting sliding sync proxy...");
+    console.log(new Date(), "Starting sliding sync proxy...");
 
     const postgresId = await dockerRun({
         image: "postgres",
@@ -64,7 +64,7 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
             });
             lastErr = null;
             break;
-        } catch(err) {
+        } catch (err) {
             console.log("pg_isready: failed");
             lastErr = err;
         }
@@ -75,7 +75,7 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
     }
 
     const port = await getFreePort();
-    console.log(new Date(),"starting proxy container...");
+    console.log(new Date(), "starting proxy container...");
     const containerId = await dockerRun({
         image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.3.3",
         containerName: "react-sdk-cypress-sliding-sync-proxy",
@@ -87,7 +87,7 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
             "-e", `SYNCV3_DB=user=postgres dbname=postgres password=${PG_PASSWORD} host=${postgresIp} sslmode=disable`,
         ],
     });
-    console.log(new Date(),"started!");
+    console.log(new Date(), "started!");
 
     const instance: ProxyInstance = { containerId, postgresId, port };
     instances.set(containerId, instance);
@@ -104,7 +104,7 @@ async function proxyStop(instance: ProxyInstance): Promise<void> {
 
     instances.delete(instance.containerId);
 
-    console.log(new Date(),"Stopped sliding sync proxy.");
+    console.log(new Date(), "Stopped sliding sync proxy.");
     // cypress deliberately fails if you return 'undefined', so
     // return null to signal all is well, and we've handled the task.
     return null;
diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json
index a0300615e69..599dc43883b 100644
--- a/src/i18n/strings/en_EN.json
+++ b/src/i18n/strings/en_EN.json
@@ -898,8 +898,8 @@
     "Use new room breadcrumbs": "Use new room breadcrumbs",
     "Right panel stays open (defaults to room member list)": "Right panel stays open (defaults to room member list)",
     "Jump to date (adds /jumptodate and jump to date headers)": "Jump to date (adds /jumptodate and jump to date headers)",
-    "Sliding Sync mode (under active development)": "Sliding Sync mode (under active development)",
     "Send read receipts": "Send read receipts",
+    "Sliding Sync mode (under active development)": "Sliding Sync mode (under active development)",
     "Live Location Sharing (temporary implementation: locations persist in room history)": "Live Location Sharing (temporary implementation: locations persist in room history)",
     "Favourite Messages (under active development)": "Favourite Messages (under active development)",
     "Use new session manager (under active development)": "Use new session manager (under active development)",
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index e6e8803dc99..e3f148025bf 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -198,7 +198,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         // no sticky room if you aren't viewing a room.
         this.stickyRoomId = RoomViewStore.instance.getRoomId();
         let stickyRoomNewIndex = -1;
-        let stickyRoomOldIndex = (tagMap[tagId] || []).findIndex((room) => {
+        const stickyRoomOldIndex = (tagMap[tagId] || []).findIndex((room) => {
             return room.roomId === this.stickyRoomId;
         });
 
@@ -286,7 +286,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
                 // resort it based on the slidingSync view of the list. This may cause this old sticky
                 // room to cease to exist.
                 const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
-                const {roomIndexToRoomId} = SlidingSyncManager.instance.slidingSync.getListData(index);
+                const { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(index);
                 this.refreshOrderedLists(tagId, roomIndexToRoomId);
                 hasUpdatedAnyList = true;
             }

From cae0c5af126297d1323a495e6a008b398f25834d Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 22 Aug 2022 16:14:54 +0100
Subject: [PATCH 63/81] only enable SS by default on netlify

---
 src/SdkConfig.ts          | 2 --
 src/settings/Settings.tsx | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/SdkConfig.ts b/src/SdkConfig.ts
index 3ada8323c38..bf3fb8699c0 100644
--- a/src/SdkConfig.ts
+++ b/src/SdkConfig.ts
@@ -90,8 +90,6 @@ export default class SdkConfig {
                 cfg[defaultKeys[i]] = DEFAULTS[defaultKeys[i]];
             }
         }
-        // XXX overrides for testing sliding sync on netlify, do not commit this to main!
-        cfg.show_labs_settings = true;
         SdkConfig.setInstance(cfg);
     }
 
diff --git a/src/settings/Settings.tsx b/src/settings/Settings.tsx
index bcae02d906f..81b1118c138 100644
--- a/src/settings/Settings.tsx
+++ b/src/settings/Settings.tsx
@@ -412,7 +412,7 @@ export const SETTINGS: {[setting: string]: ISetting} = {
         labsGroup: LabGroup.Developer,
         supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
         displayName: _td('Sliding Sync mode (under active development)'),
-        default: true, // XXX: overrides for testing sliding sync on netlify, do not commit this to main!
+        default: window.location.hostname === "pr8328--matrix-react-sdk.netlify.app", // XXX: overrides for testing sliding sync on netlify, do not commit this to main!
         controller: new SlidingSyncController(),
     },
     "feature_location_share_live": {

From 3347657569feccff9b3180a5832fb898763ef39e Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 22 Aug 2022 16:38:19 +0100
Subject: [PATCH 64/81] Jest fixes; merge conflict fixes; remove debug logging;
 use right sort enum values

---
 src/components/views/rooms/RoomSublist.tsx | 4 +---
 test/stores/RoomViewStore-test.tsx         | 1 +
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 434580679a9..761f2946f3f 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -100,7 +100,6 @@ interface IState {
     isExpanded: boolean; // used for the for expand of the sublist when the room list is being filtered
     height: number;
     rooms: Room[];
-    filteredExtraTiles?: ReactComponentElement<typeof ExtraTile>[];
     roomsLoading: boolean;
 }
 
@@ -271,7 +270,6 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         if (this.props.tagId !== tagId) {
             return;
         }
-        console.log("sliding onListsLoading ", tagId, isLoading);
         this.setState({
             roomsLoading: isLoading,
         });
@@ -575,7 +573,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
                 isAlphabetical = slidingList.sort[0] === "by_name";
                 isUnreadFirst = (
                     slidingList.sort[0] === "by_highlight_count" ||
-                    slidingList.sort[0] === "by_unread_count"
+                    slidingList.sort[0] === "by_notification_count"
                 );
             }
 
diff --git a/test/stores/RoomViewStore-test.tsx b/test/stores/RoomViewStore-test.tsx
index 15137835597..af10e4d693e 100644
--- a/test/stores/RoomViewStore-test.tsx
+++ b/test/stores/RoomViewStore-test.tsx
@@ -49,6 +49,7 @@ describe('RoomViewStore', function() {
         mockClient.credentials = { userId: "@test:example.com" };
         mockClient.joinRoom.mockResolvedValue(room);
         mockClient.getRoom.mockReturnValue(room);
+        mockClient.isGuest.mockReturnValue(false);
 
         // Reset the state of the store
         RoomViewStore.instance.reset();

From 410d90d43da20c9bc3ed7c29f3f81992a653953d Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 22 Aug 2022 16:50:20 +0100
Subject: [PATCH 65/81] Actually fix jest tests

---
 test/stores/RoomViewStore-test.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/stores/RoomViewStore-test.tsx b/test/stores/RoomViewStore-test.tsx
index af10e4d693e..b505fc6e6db 100644
--- a/test/stores/RoomViewStore-test.tsx
+++ b/test/stores/RoomViewStore-test.tsx
@@ -41,6 +41,7 @@ describe('RoomViewStore', function() {
         joinRoom: jest.fn(),
         getRoom: jest.fn(),
         getRoomIdForAlias: jest.fn(),
+        isGuest: jest.fn(),
     });
     const room = new Room('!room:server', mockClient, userId);
 

From 5e308b4d56f5c0556a29003df9b8213a933f369c Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 23 Aug 2022 10:08:50 +0100
Subject: [PATCH 66/81] Add support for favourites and low priority

---
 src/stores/room-list/SlidingRoomListStore.ts | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index e3f148025bf..ddcaf7f8618 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -45,8 +45,11 @@ const filterConditions: Record<TagID, MSC3575Filter> = {
     [DefaultTagID.Invite]: {
         is_invite: true,
     },
+    [DefaultTagID.Favourite]: {
+        tags: ["m.favourite"],
+        is_tombstoned: false,
+    },
     // TODO
-    // DefaultTagID.Favourite,
     // DefaultTagID.SavedItems,
     [DefaultTagID.DM]: {
         is_dm: true,
@@ -58,10 +61,14 @@ const filterConditions: Record<TagID, MSC3575Filter> = {
         is_invite: false,
         is_tombstoned: false,
         not_room_types: ["m.space"],
+        not_tags: ["m.favourite", "m.lowpriority"],
         // spaces filter added dynamically
     },
+    [DefaultTagID.LowPriority]: {
+        tags: ["m.lowpriority"],
+        is_tombstoned: false,
+    },
     // TODO
-    // DefaultTagID.LowPriority,
     // DefaultTagID.ServerNotice,
     // DefaultTagID.Suggested,
     // DefaultTagID.Archived,

From cf728cee291599931383e45ab02249487640cf20 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Thu, 25 Aug 2022 11:06:19 +0100
Subject: [PATCH 67/81] Bump sliding sync version

---
 cypress/plugins/sliding-sync/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cypress/plugins/sliding-sync/index.ts b/cypress/plugins/sliding-sync/index.ts
index 8e2599bfa02..61a62aad13c 100644
--- a/cypress/plugins/sliding-sync/index.ts
+++ b/cypress/plugins/sliding-sync/index.ts
@@ -77,7 +77,7 @@ async function proxyStart(synapse: SynapseInstance): Promise<ProxyInstance> {
     const port = await getFreePort();
     console.log(new Date(), "starting proxy container...");
     const containerId = await dockerRun({
-        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.3.3",
+        image: "ghcr.io/matrix-org/sliding-sync-proxy:v0.4.0",
         containerName: "react-sdk-cypress-sliding-sync-proxy",
         params: [
             "--rm",

From 70eaa2384c453cd94d067ab832855aa9094a93ee Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Thu, 25 Aug 2022 14:53:11 +0100
Subject: [PATCH 68/81] Update sliding sync labs to be user configurable

---
 cypress/e2e/sliding-sync/sliding-sync.ts      |   4 +-
 src/IConfigOptions.ts                         |   1 -
 src/MatrixClientPeg.ts                        |  13 +-
 src/SdkConfig.ts                              |   2 -
 src/SlidingSyncManager.ts                     |   2 +-
 .../dialogs/SlidingSyncOptionsDialog.tsx      | 134 ++++++++++++++++++
 .../views/dialogs/TextInputDialog.tsx         |   4 +-
 src/i18n/strings/en_EN.json                   |  11 +-
 src/settings/Settings.tsx                     |   8 +-
 .../controllers/SlidingSyncController.ts      |  59 ++------
 10 files changed, 173 insertions(+), 65 deletions(-)
 create mode 100644 src/components/views/dialogs/SlidingSyncOptionsDialog.tsx

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index f06dd53a3ce..1399f71b6dc 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -40,7 +40,9 @@ describe("Sliding Sync", () => {
                 return req.continue(res => {
                     res.send(200, {
                         ...res.body,
-                        sliding_sync_proxy_url: `http://localhost:${proxy.port}`,
+                        setting_defaults: {
+                            feature_sliding_sync_proxy_url: `http://localhost:${proxy.port}`,
+                        },
                     });
                 });
             });
diff --git a/src/IConfigOptions.ts b/src/IConfigOptions.ts
index 3185bd3ec35..395a97d3d42 100644
--- a/src/IConfigOptions.ts
+++ b/src/IConfigOptions.ts
@@ -158,7 +158,6 @@ export interface IConfigOptions {
         domains?: string[];
     };
 
-    sliding_sync_proxy_url?: string;
     enable_presence_by_hs_url?: Record<string, boolean>; // <HomeserverName, Enabled>
 
     terms_and_conditions_links?: { url: string, text: string }[];
diff --git a/src/MatrixClientPeg.ts b/src/MatrixClientPeg.ts
index 1120b9e28d8..9001f46f35a 100644
--- a/src/MatrixClientPeg.ts
+++ b/src/MatrixClientPeg.ts
@@ -36,7 +36,6 @@ import * as StorageManager from './utils/StorageManager';
 import IdentityAuthClient from './IdentityAuthClient';
 import { crossSigningCallbacks, tryToUnlockSecretStorageWithDehydrationKey } from './SecurityManager';
 import SecurityCustomisations from "./customisations/Security";
-import SdkConfig from './SdkConfig';
 import { SlidingSyncManager } from './SlidingSyncManager';
 import CryptoStoreTooNewDialog from "./components/views/dialogs/CryptoStoreTooNewDialog";
 
@@ -238,10 +237,16 @@ class MatrixClientPegClass implements IMatrixClientPeg {
         opts.clientWellKnownPollPeriod = 2 * 60 * 60; // 2 hours
         opts.experimentalThreadSupport = SettingsStore.getValue("feature_thread");
 
-        if (SdkConfig.get().sliding_sync_proxy_url && SettingsStore.getValue("feature_sliding_sync")) {
-            logger.log("Activating sliding sync using proxy at ", SdkConfig.get().sliding_sync_proxy_url);
+        if (SettingsStore.getValue("feature_sliding_sync")) {
+            const proxyUrl = SettingsStore.getValue("feature_sliding_sync_proxy_url");
+            if (proxyUrl) {
+                logger.log("Activating sliding sync using proxy at ", proxyUrl);
+            } else {
+                logger.log("Activating sliding sync");
+            }
             opts.slidingSync = SlidingSyncManager.instance.configure(
-                this.matrixClient, SdkConfig.get().sliding_sync_proxy_url,
+                this.matrixClient,
+                proxyUrl || this.matrixClient.baseUrl,
             );
         }
 
diff --git a/src/SdkConfig.ts b/src/SdkConfig.ts
index bf3fb8699c0..51feb9a6970 100644
--- a/src/SdkConfig.ts
+++ b/src/SdkConfig.ts
@@ -27,8 +27,6 @@ export const DEFAULTS: IConfigOptions = {
     integrations_ui_url: "https://scalar.vector.im/",
     integrations_rest_url: "https://scalar.vector.im/api",
     bug_report_endpoint_url: null,
-    // The location of the sliding sync proxy. If not specified, sliding sync mode cannot be enabled.
-    sliding_sync_proxy_url: "https://slidingsync.lab.element.dev",
 
     // Jitsi conference options
     jitsi: {
diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 8dde2d70656..dd8f4e36090 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -95,7 +95,7 @@ export class SlidingSyncManager {
         return SlidingSyncManager.internalInstance;
     }
 
-    public configure(client: MatrixClient, proxyUrl: string): SlidingSync {
+    public configure(client: MatrixClient, proxyUrl?: string): SlidingSync {
         this.client = client;
         this.listIdToIndex = {};
         this.slidingSync = new SlidingSync(
diff --git a/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx b/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
new file mode 100644
index 00000000000..c4c82860546
--- /dev/null
+++ b/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
@@ -0,0 +1,134 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import React from 'react';
+import { MatrixClient } from 'matrix-js-sdk/src/matrix';
+import { logger } from 'matrix-js-sdk/src/logger';
+
+import { _t, _td } from '../../../languageHandler';
+import { IDialogProps } from "./IDialogProps";
+import SettingsStore from "../../../settings/SettingsStore";
+import TextInputDialog from "./TextInputDialog";
+import withValidation from "../elements/Validation";
+import { MatrixClientPeg } from "../../../MatrixClientPeg";
+import { useAsyncMemo } from "../../../hooks/useAsyncMemo";
+import { SettingLevel } from "../../../settings/SettingLevel";
+import PlatformPeg from "../../../PlatformPeg";
+
+/**
+ * Check that the server natively supports sliding sync.
+ * @param cli The MatrixClient of the logged in user.
+ * @throws if the proxy server is unreachable or not configured to the given homeserver
+ */
+async function syncHealthCheck(cli: MatrixClient): Promise<void> {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), 10 * 1000); // 10s
+    const url = cli.http.getUrl("/sync", {}, "/_matrix/client/unstable/org.matrix.msc3575");
+    const res = await fetch(url, {
+        signal: controller.signal,
+        method: "POST",
+    });
+    clearTimeout(id);
+    if (res.status != 200) {
+        throw new Error(`syncHealthCheck: server returned HTTP ${res.status}`);
+    }
+    logger.info("server natively support sliding sync OK");
+}
+
+/**
+ * Check that the proxy url is in fact a sliding sync proxy endpoint and it is up.
+ * @param endpoint The proxy endpoint url
+ * @param hsUrl The homeserver url of the logged in user.
+ * @throws if the proxy server is unreachable or not configured to the given homeserver
+ */
+async function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<void> {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), 10 * 1000); // 10s
+    const res = await fetch(endpoint + "/client/server.json", {
+        signal: controller.signal,
+    });
+    clearTimeout(id);
+    if (res.status != 200) {
+        throw new Error(`proxyHealthCheck: proxy server returned HTTP ${res.status}`);
+    }
+    const body = await res.json();
+    if (body.server !== hsUrl) {
+        throw new Error(`proxyHealthCheck: client using ${hsUrl} but server is as ${body.server}`);
+    }
+    logger.info("sliding sync proxy is OK");
+}
+
+export const SlidingSyncOptionsDialog: React.FC<IDialogProps> = ({ onFinished }) => {
+    const cli = MatrixClientPeg.get();
+    const enabled = SettingsStore.getValue("feature_sliding_sync");
+    const currentProxy = SettingsStore.getValue("feature_sliding_sync_proxy_url");
+    const hasNativeSupport = useAsyncMemo(() => syncHealthCheck(cli).then(() => true, () => false), [], null);
+
+    let nativeSupport: string;
+    if (hasNativeSupport === null) {
+        nativeSupport = _t("Checking...");
+    } else {
+        nativeSupport = hasNativeSupport
+            ? _t("Your server has native support")
+            : _t("Your server lacks native support");
+    }
+
+    const validProxy = withValidation<undefined, { error?: Error }>({
+        async deriveData({ value }): Promise<{ error?: Error }> {
+            try {
+                await proxyHealthCheck(value, MatrixClientPeg.get().baseUrl);
+                return {};
+            } catch (error) {
+                return { error };
+            }
+        },
+        rules: [
+            {
+                key: "required",
+                test: async ({ value }) => !!value || hasNativeSupport,
+                invalid: () => _t("Your server lacks native support, you must specify a proxy"),
+            }, {
+                key: "working",
+                final: true,
+                test: async (_, { error }) => !error,
+                valid: () => _t("Looks good"),
+                invalid: ({ error }) => error?.message,
+            },
+        ],
+    });
+
+    return <TextInputDialog
+        title={_t("Sliding Sync configuration")}
+        description={nativeSupport}
+        placeholder={hasNativeSupport ? _t('Proxy URL') : _t('Proxy URL (optional)')}
+        value={currentProxy}
+        button={_t("Save")}
+        cancelButton={_t("Disable")}
+        validator={validProxy}
+        onFinished={(enable: boolean, proxyUrl: string) => {
+            if (enable) {
+                SettingsStore.setValue("feature_sliding_sync_proxy_url", null, SettingLevel.DEVICE, proxyUrl);
+                onFinished(true);
+                if (enabled && proxyUrl !== currentProxy) {
+                    // We're changing proxy URL here, cause a reload
+                    PlatformPeg.get().reload();
+                }
+            } else {
+                onFinished(false);
+            }
+        }}
+    />;
+};
diff --git a/src/components/views/dialogs/TextInputDialog.tsx b/src/components/views/dialogs/TextInputDialog.tsx
index 7a13fd3d453..06ad9366608 100644
--- a/src/components/views/dialogs/TextInputDialog.tsx
+++ b/src/components/views/dialogs/TextInputDialog.tsx
@@ -29,10 +29,11 @@ interface IProps extends IDialogProps {
     value?: string;
     placeholder?: string;
     button?: string;
+    cancelButton?: string;
     busyMessage?: string; // pass _td string
     focus?: boolean;
     hasCancel?: boolean;
-    validator?: (fieldState: IFieldState) => IValidationResult; // result of withValidation
+    validator?: (fieldState: IFieldState) => Promise<IValidationResult>; // result of withValidation
     fixedWidth?: boolean;
 }
 
@@ -134,6 +135,7 @@ export default class TextInputDialog extends React.Component<IProps, IState> {
                 </form>
                 <DialogButtons
                     primaryButton={this.state.busy ? _t(this.props.busyMessage) : this.props.button}
+                    cancelButton={this.props.cancelButton}
                     disabled={this.state.busy}
                     onPrimaryButtonClick={this.onOk}
                     onCancel={this.onCancel}
diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json
index 599dc43883b..8382445b6e1 100644
--- a/src/i18n/strings/en_EN.json
+++ b/src/i18n/strings/en_EN.json
@@ -899,7 +899,7 @@
     "Right panel stays open (defaults to room member list)": "Right panel stays open (defaults to room member list)",
     "Jump to date (adds /jumptodate and jump to date headers)": "Jump to date (adds /jumptodate and jump to date headers)",
     "Send read receipts": "Send read receipts",
-    "Sliding Sync mode (under active development)": "Sliding Sync mode (under active development)",
+    "Sliding Sync mode (under active development, requires server or proxy support)": "Sliding Sync mode (under active development, requires server or proxy support)",
     "Live Location Sharing (temporary implementation: locations persist in room history)": "Live Location Sharing (temporary implementation: locations persist in room history)",
     "Favourite Messages (under active development)": "Favourite Messages (under active development)",
     "Use new session manager (under active development)": "Use new session manager (under active development)",
@@ -2846,6 +2846,14 @@
     "Link to selected message": "Link to selected message",
     "Link to room": "Link to room",
     "Command Help": "Command Help",
+    "Checking...": "Checking...",
+    "Your server has native support": "Your server has native support",
+    "Your server lacks native support": "Your server lacks native support",
+    "Your server lacks native support, you must specify a proxy": "Your server lacks native support, you must specify a proxy",
+    "Sliding Sync configuration": "Sliding Sync configuration",
+    "Proxy URL": "Proxy URL",
+    "Proxy URL (optional)": "Proxy URL (optional)",
+    "Disable": "Disable",
     "Sections to show": "Sections to show",
     "This groups your chats with members of this space. Turning this off will hide those chats from your view of %(spaceName)s.": "This groups your chats with members of this space. Turning this off will hide those chats from your view of %(spaceName)s.",
     "Space settings": "Space settings",
@@ -3443,7 +3451,6 @@
     "If you did this accidentally, you can setup Secure Messages on this session which will re-encrypt this session's message history with a new recovery method.": "If you did this accidentally, you can setup Secure Messages on this session which will re-encrypt this session's message history with a new recovery method.",
     "If you didn't remove the recovery method, an attacker may be trying to access your account. Change your account password and set a new recovery method immediately in Settings.": "If you didn't remove the recovery method, an attacker may be trying to access your account. Change your account password and set a new recovery method immediately in Settings.",
     "If disabled, messages from encrypted rooms won't appear in search results.": "If disabled, messages from encrypted rooms won't appear in search results.",
-    "Disable": "Disable",
     "Not currently indexing messages for any room.": "Not currently indexing messages for any room.",
     "Currently indexing: %(currentRoom)s": "Currently indexing: %(currentRoom)s",
     "%(brand)s is securely caching encrypted messages locally for them to appear in search results:": "%(brand)s is securely caching encrypted messages locally for them to appear in search results:",
diff --git a/src/settings/Settings.tsx b/src/settings/Settings.tsx
index 81b1118c138..62010363f7d 100644
--- a/src/settings/Settings.tsx
+++ b/src/settings/Settings.tsx
@@ -411,10 +411,14 @@ export const SETTINGS: {[setting: string]: ISetting} = {
         isFeature: true,
         labsGroup: LabGroup.Developer,
         supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
-        displayName: _td('Sliding Sync mode (under active development)'),
-        default: window.location.hostname === "pr8328--matrix-react-sdk.netlify.app", // XXX: overrides for testing sliding sync on netlify, do not commit this to main!
+        displayName: _td('Sliding Sync mode (under active development, requires server or proxy support)'),
+        default: false,
         controller: new SlidingSyncController(),
     },
+    "feature_sliding_sync_proxy_url": {
+        supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
+        default: "",
+    },
     "feature_location_share_live": {
         isFeature: true,
         labsGroup: LabGroup.Messaging,
diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
index c351e9b5b7f..f10675c4892 100644
--- a/src/settings/controllers/SlidingSyncController.ts
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -14,63 +14,20 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from "matrix-js-sdk/src/logger";
-
 import SettingController from "./SettingController";
 import PlatformPeg from "../../PlatformPeg";
 import { SettingLevel } from "../SettingLevel";
-import SdkConfig from "../../SdkConfig";
-import SettingsStore from "../SettingsStore";
-import { MatrixClientPeg } from "../../MatrixClientPeg";
+import { SlidingSyncOptionsDialog } from "../../components/views/dialogs/SlidingSyncOptionsDialog";
+import Modal from "../../Modal";
 
 export default class SlidingSyncController extends SettingController {
-    public async onChange(level: SettingLevel, roomId: string, newValue: any) {
-        if (newValue) {
-            // run checks against the "proxy" to make sure it is valid BEFORE we start doing things
-            const url = SdkConfig.get().sliding_sync_proxy_url;
-            if (!url) {
-                logger.error("cannot enable sliding sync without 'sliding_sync_proxy_url' being present");
-                return;
-            }
-            try {
-                await proxyHealthCheck(url, MatrixClientPeg.get().baseUrl);
-            } catch (err) {
-                logger.error("sliding sync proxy not ok: " + err);
-                // force the value to false, this is a bit ew, it would be nice if we could return
-                // a bool as to whether to go through with the change or not.
-                SettingsStore.setValue("feature_sliding_sync", roomId, level, false);
-                return;
-            }
-        }
-        PlatformPeg.get().reload();
+    public async beforeChange(level: SettingLevel, roomId: string, newValue: any): Promise<boolean> {
+        const { finished } = Modal.createDialog(SlidingSyncOptionsDialog);
+        const [value] = await finished;
+        return newValue === value; // abort the operation if we're already in the state the user chose via modal
     }
 
-    public get settingDisabled(): boolean {
-        return !SdkConfig.get().sliding_sync_proxy_url;
-    }
-}
-
-/**
- * Check that the proxy url is in fact a sliding sync proxy endpoint and it is up.
- * @param endpoint The proxy endpoint url
- * @param hsUrl The homeserver url of the logged in user.
- * @throws if the proxy server is unreachable or not configured to the given homeserver
- */
-async function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<any> {
-    // TODO: when HSes natively support sliding sync, we should just hit the /sync endpoint to see
-    // if it 200 OKs.
-    const controller = new AbortController();
-    const id = setTimeout(() => controller.abort(), 10 * 1000); // 10s
-    const res = await fetch(endpoint + "/client/server.json", {
-        signal: controller.signal,
-    });
-    clearTimeout(id);
-    if (res.status != 200) {
-        throw new Error(`proxyHealthCheck: proxy server returned HTTP ${res.status}`);
-    }
-    const body = await res.json();
-    if (body.server !== hsUrl) {
-        throw new Error(`proxyHealthCheck: client using ${hsUrl} but server is as ${body.server}`);
+    public async onChange(): Promise<void> {
+        PlatformPeg.get().reload();
     }
-    logger.info("sliding sync proxy is OK");
 }

From aa89bb49c17035a142ee082f50e4413075d68caf Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Thu, 25 Aug 2022 15:02:33 +0100
Subject: [PATCH 69/81] delint

---
 src/components/views/dialogs/SlidingSyncOptionsDialog.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx b/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
index c4c82860546..41f86e74429 100644
--- a/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
+++ b/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
@@ -18,7 +18,7 @@ import React from 'react';
 import { MatrixClient } from 'matrix-js-sdk/src/matrix';
 import { logger } from 'matrix-js-sdk/src/logger';
 
-import { _t, _td } from '../../../languageHandler';
+import { _t } from '../../../languageHandler';
 import { IDialogProps } from "./IDialogProps";
 import SettingsStore from "../../../settings/SettingsStore";
 import TextInputDialog from "./TextInputDialog";

From d089c1ec22292e978cf8730fb24f3fadf6a8c2b0 Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Fri, 26 Aug 2022 10:47:02 +0100
Subject: [PATCH 70/81] To disable SS or change proxy URL the user has to log
 out

---
 .../views/dialogs/SlidingSyncOptionsDialog.tsx   | 16 ++++++----------
 src/components/views/dialogs/TextInputDialog.tsx |  2 --
 src/i18n/strings/en_EN.json                      |  7 ++++---
 src/settings/Settings.tsx                        |  2 +-
 .../controllers/SlidingSyncController.ts         |  6 ++++++
 5 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx b/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
index 41f86e74429..ed793231b21 100644
--- a/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
+++ b/src/components/views/dialogs/SlidingSyncOptionsDialog.tsx
@@ -26,7 +26,6 @@ import withValidation from "../elements/Validation";
 import { MatrixClientPeg } from "../../../MatrixClientPeg";
 import { useAsyncMemo } from "../../../hooks/useAsyncMemo";
 import { SettingLevel } from "../../../settings/SettingLevel";
-import PlatformPeg from "../../../PlatformPeg";
 
 /**
  * Check that the server natively supports sliding sync.
@@ -73,7 +72,6 @@ async function proxyHealthCheck(endpoint: string, hsUrl?: string): Promise<void>
 
 export const SlidingSyncOptionsDialog: React.FC<IDialogProps> = ({ onFinished }) => {
     const cli = MatrixClientPeg.get();
-    const enabled = SettingsStore.getValue("feature_sliding_sync");
     const currentProxy = SettingsStore.getValue("feature_sliding_sync_proxy_url");
     const hasNativeSupport = useAsyncMemo(() => syncHealthCheck(cli).then(() => true, () => false), [], null);
 
@@ -112,20 +110,18 @@ export const SlidingSyncOptionsDialog: React.FC<IDialogProps> = ({ onFinished })
 
     return <TextInputDialog
         title={_t("Sliding Sync configuration")}
-        description={nativeSupport}
-        placeholder={hasNativeSupport ? _t('Proxy URL') : _t('Proxy URL (optional)')}
+        description={<div>
+            <div><b>{ _t("To disable you will need to log out and back in, use with caution!") }</b></div>
+            { nativeSupport }
+        </div>}
+        placeholder={hasNativeSupport ? _t('Proxy URL (optional)') : _t('Proxy URL')}
         value={currentProxy}
-        button={_t("Save")}
-        cancelButton={_t("Disable")}
+        button={_t("Enable")}
         validator={validProxy}
         onFinished={(enable: boolean, proxyUrl: string) => {
             if (enable) {
                 SettingsStore.setValue("feature_sliding_sync_proxy_url", null, SettingLevel.DEVICE, proxyUrl);
                 onFinished(true);
-                if (enabled && proxyUrl !== currentProxy) {
-                    // We're changing proxy URL here, cause a reload
-                    PlatformPeg.get().reload();
-                }
             } else {
                 onFinished(false);
             }
diff --git a/src/components/views/dialogs/TextInputDialog.tsx b/src/components/views/dialogs/TextInputDialog.tsx
index 06ad9366608..6de0c74ba5c 100644
--- a/src/components/views/dialogs/TextInputDialog.tsx
+++ b/src/components/views/dialogs/TextInputDialog.tsx
@@ -29,7 +29,6 @@ interface IProps extends IDialogProps {
     value?: string;
     placeholder?: string;
     button?: string;
-    cancelButton?: string;
     busyMessage?: string; // pass _td string
     focus?: boolean;
     hasCancel?: boolean;
@@ -135,7 +134,6 @@ export default class TextInputDialog extends React.Component<IProps, IState> {
                 </form>
                 <DialogButtons
                     primaryButton={this.state.busy ? _t(this.props.busyMessage) : this.props.button}
-                    cancelButton={this.props.cancelButton}
                     disabled={this.state.busy}
                     onPrimaryButtonClick={this.onOk}
                     onCancel={this.onCancel}
diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json
index 8382445b6e1..2d8702d5bd4 100644
--- a/src/i18n/strings/en_EN.json
+++ b/src/i18n/strings/en_EN.json
@@ -899,7 +899,7 @@
     "Right panel stays open (defaults to room member list)": "Right panel stays open (defaults to room member list)",
     "Jump to date (adds /jumptodate and jump to date headers)": "Jump to date (adds /jumptodate and jump to date headers)",
     "Send read receipts": "Send read receipts",
-    "Sliding Sync mode (under active development, requires server or proxy support)": "Sliding Sync mode (under active development, requires server or proxy support)",
+    "Sliding Sync mode (under active development, cannot be disabled)": "Sliding Sync mode (under active development, cannot be disabled)",
     "Live Location Sharing (temporary implementation: locations persist in room history)": "Live Location Sharing (temporary implementation: locations persist in room history)",
     "Favourite Messages (under active development)": "Favourite Messages (under active development)",
     "Use new session manager (under active development)": "Use new session manager (under active development)",
@@ -2851,9 +2851,9 @@
     "Your server lacks native support": "Your server lacks native support",
     "Your server lacks native support, you must specify a proxy": "Your server lacks native support, you must specify a proxy",
     "Sliding Sync configuration": "Sliding Sync configuration",
-    "Proxy URL": "Proxy URL",
+    "To disable you will need to log out and back in, use with caution!": "To disable you will need to log out and back in, use with caution!",
     "Proxy URL (optional)": "Proxy URL (optional)",
-    "Disable": "Disable",
+    "Proxy URL": "Proxy URL",
     "Sections to show": "Sections to show",
     "This groups your chats with members of this space. Turning this off will hide those chats from your view of %(spaceName)s.": "This groups your chats with members of this space. Turning this off will hide those chats from your view of %(spaceName)s.",
     "Space settings": "Space settings",
@@ -3451,6 +3451,7 @@
     "If you did this accidentally, you can setup Secure Messages on this session which will re-encrypt this session's message history with a new recovery method.": "If you did this accidentally, you can setup Secure Messages on this session which will re-encrypt this session's message history with a new recovery method.",
     "If you didn't remove the recovery method, an attacker may be trying to access your account. Change your account password and set a new recovery method immediately in Settings.": "If you didn't remove the recovery method, an attacker may be trying to access your account. Change your account password and set a new recovery method immediately in Settings.",
     "If disabled, messages from encrypted rooms won't appear in search results.": "If disabled, messages from encrypted rooms won't appear in search results.",
+    "Disable": "Disable",
     "Not currently indexing messages for any room.": "Not currently indexing messages for any room.",
     "Currently indexing: %(currentRoom)s": "Currently indexing: %(currentRoom)s",
     "%(brand)s is securely caching encrypted messages locally for them to appear in search results:": "%(brand)s is securely caching encrypted messages locally for them to appear in search results:",
diff --git a/src/settings/Settings.tsx b/src/settings/Settings.tsx
index 62010363f7d..0428d766769 100644
--- a/src/settings/Settings.tsx
+++ b/src/settings/Settings.tsx
@@ -411,7 +411,7 @@ export const SETTINGS: {[setting: string]: ISetting} = {
         isFeature: true,
         labsGroup: LabGroup.Developer,
         supportedLevels: LEVELS_DEVICE_ONLY_SETTINGS_WITH_CONFIG,
-        displayName: _td('Sliding Sync mode (under active development, requires server or proxy support)'),
+        displayName: _td('Sliding Sync mode (under active development, cannot be disabled)'),
         default: false,
         controller: new SlidingSyncController(),
     },
diff --git a/src/settings/controllers/SlidingSyncController.ts b/src/settings/controllers/SlidingSyncController.ts
index f10675c4892..fdbea7bda0a 100644
--- a/src/settings/controllers/SlidingSyncController.ts
+++ b/src/settings/controllers/SlidingSyncController.ts
@@ -19,6 +19,7 @@ import PlatformPeg from "../../PlatformPeg";
 import { SettingLevel } from "../SettingLevel";
 import { SlidingSyncOptionsDialog } from "../../components/views/dialogs/SlidingSyncOptionsDialog";
 import Modal from "../../Modal";
+import SettingsStore from "../SettingsStore";
 
 export default class SlidingSyncController extends SettingController {
     public async beforeChange(level: SettingLevel, roomId: string, newValue: any): Promise<boolean> {
@@ -30,4 +31,9 @@ export default class SlidingSyncController extends SettingController {
     public async onChange(): Promise<void> {
         PlatformPeg.get().reload();
     }
+
+    public get settingDisabled(): boolean {
+        // Cannot be disabled once enabled, user has been warned and must log out and back in.
+        return SettingsStore.getValue("feature_sliding_sync");
+    }
 }

From 3889bd48373303a053b945f74b583843c132ec00 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 30 Aug 2022 10:48:15 +0100
Subject: [PATCH 71/81] Review comments

---
 cypress/e2e/sliding-sync/sliding-sync.ts   | 19 ++++------------
 src/SlidingSyncManager.ts                  | 26 +++++++++-------------
 src/components/views/rooms/RoomSublist.tsx |  2 +-
 src/hooks/useSlidingSyncRoomSearch.ts      |  4 ++--
 4 files changed, 17 insertions(+), 34 deletions(-)

diff --git a/cypress/e2e/sliding-sync/sliding-sync.ts b/cypress/e2e/sliding-sync/sliding-sync.ts
index 1399f71b6dc..5b5ec5145e0 100644
--- a/cypress/e2e/sliding-sync/sliding-sync.ts
+++ b/cypress/e2e/sliding-sync/sliding-sync.ts
@@ -79,22 +79,11 @@ describe("Sliding Sync", () => {
     };
     const createAndJoinBob = () => {
         // create a Bob user
-        let baseUrl;
-        let creds;
         cy.get<SynapseInstance>("@synapse").then((synapse) => {
-            baseUrl = synapse.baseUrl;
-            return cy.registerUser(synapse, "bob", "passwordgoeshere123", "Bob");
-        }).then((c) => {
-            creds = c;
-            return cy.window({ log: false });
-        }).then((window) => {
-            return window.matrixcs.createClient({
-                baseUrl: baseUrl,
-                accessToken: creds.accessToken,
-                userId: creds.userId,
-                deviceId: creds.deviceId,
-            });
-        }).as("bob");
+            return cy.getBot(synapse, {
+                displayName: "Bob",
+            }).as("bob");
+        });
 
         // invite Bob to Test Room and accept then send a message.
         cy.all([cy.get<string>("@roomId"), cy.get<MatrixClient>("@bob")]).then(([roomId, bob]) => {
diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index dd8f4e36090..bee43b79586 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -219,22 +219,16 @@ export class SlidingSyncManager {
             subscriptions.delete(roomId);
         }
         logger.log("SlidingSync setRoomVisible:", roomId, visible);
-        this.slidingSync.modifyRoomSubscriptions(subscriptions);
-
-        return new Promise((resolve) => {
-            if (this.client.getRoom(roomId)) {
-                resolve(roomId); // we have data already for this room, show immediately e.g it's in a list
-                return;
-            }
-            const resolveOnSubscribed = (gotRoomId: string) => {
-                if (roomId === gotRoomId) {
-                    // we processed a /sync response which returned this subscription
-                    this.slidingSync.off(SlidingSyncEvent.RoomData, resolveOnSubscribed);
-                    resolve(roomId);
-                }
-            };
+        const p = this.slidingSync.modifyRoomSubscriptions(subscriptions);
+        if (this.client.getRoom(roomId)) {
+            return roomId; // we have data already for this room, show immediately e.g it's in a list
+        }
+        try {
             // wait until the next sync before returning as RoomView may need to know the current state
-            this.slidingSync.on(SlidingSyncEvent.RoomData, resolveOnSubscribed);
-        });
+            await p;
+        } catch (err) {
+            logger.warn("SlidingSync setRoomVisible:", roomId, visible, "failed to confirm transaction");
+        }
+        return roomId;
     }
 }
diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 761f2946f3f..2b3aeb0506d 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -249,7 +249,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
         return false;
     }
 
-    public async componentDidMount() {
+    public componentDidMount() {
         this.dispatcherRef = defaultDispatcher.register(this.onAction);
         RoomListStore.instance.on(LISTS_UPDATE_EVENT, this.onListsUpdated);
         RoomListStore.instance.on(LISTS_LOADING_EVENT, this.onListsLoading);
diff --git a/src/hooks/useSlidingSyncRoomSearch.ts b/src/hooks/useSlidingSyncRoomSearch.ts
index 42be40142af..93775f1baee 100644
--- a/src/hooks/useSlidingSyncRoomSearch.ts
+++ b/src/hooks/useSlidingSyncRoomSearch.ts
@@ -21,7 +21,7 @@ import { MatrixClientPeg } from "../MatrixClientPeg";
 import { useLatestResult } from "./useLatestResult";
 import { SlidingSyncManager } from "../SlidingSyncManager";
 
-export interface ISlidingSyncRoomSearchOpts {
+export interface SlidingSyncRoomSearchOpts {
     limit: number;
     query?: string;
 }
@@ -37,7 +37,7 @@ export const useSlidingSyncRoomSearch = () => {
     const search = useCallback(async ({
         limit = 100,
         query: term,
-    }: ISlidingSyncRoomSearchOpts): Promise<boolean> => {
+    }: SlidingSyncRoomSearchOpts): Promise<boolean> => {
         const opts = { limit, term };
         updateQuery(opts);
 

From f1481c6563d73be6b30a3f48a89eeb561e9a53cd Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Tue, 30 Aug 2022 11:58:31 +0100
Subject: [PATCH 72/81] Linting

---
 src/SlidingSyncManager.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index bee43b79586..249d8a2b564 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -49,7 +49,6 @@ import { EventType } from 'matrix-js-sdk/src/@types/event';
 import {
     MSC3575Filter,
     MSC3575List, SlidingSync,
-    SlidingSyncEvent,
 } from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";
 

From 4d3fcabdad0d030209ffa6f5e3e3aa07bbeaf552 Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Mon, 5 Sep 2022 09:40:16 +0100
Subject: [PATCH 73/81] Apply suggestions from code review

Co-authored-by: Travis Ralston <travisr@matrix.org>
---
 src/SlidingSyncManager.ts | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 249d8a2b564..7b7cb633402 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -48,7 +48,8 @@ import { MatrixClient } from 'matrix-js-sdk/src/matrix';
 import { EventType } from 'matrix-js-sdk/src/@types/event';
 import {
     MSC3575Filter,
-    MSC3575List, SlidingSync,
+    MSC3575List, 
+    SlidingSync,
 } from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";
 
@@ -83,7 +84,7 @@ export class SlidingSyncManager {
     private configurePromise: Promise<void>;
     private configureResolve: Function;
 
-    constructor() {
+    public constructor() {
         this.listIdToIndex = {};
         this.configurePromise = new Promise((resolve) => {
             this.configureResolve = resolve;
@@ -163,7 +164,7 @@ export class SlidingSyncManager {
      * @param updateArgs The fields to update on the list.
      * @returns The complete list request params
      */
-    async ensureListRegistered(
+    public async ensureListRegistered(
         listIndex: number, updateArgs: PartialSlidingSyncRequest,
     ): Promise<MSC3575List> {
         logger.debug("ensureListRegistered:::", listIndex, updateArgs);
@@ -209,7 +210,7 @@ export class SlidingSyncManager {
         return this.slidingSync.getList(listIndex);
     }
 
-    async setRoomVisible(roomId: string, visible: boolean): Promise<string> {
+    public async setRoomVisible(roomId: string, visible: boolean): Promise<string> {
         await this.configurePromise;
         const subscriptions = this.slidingSync.getRoomSubscriptions();
         if (visible) {

From 54e57637628d9cbb4d64c4d7a048e32304c09ba6 Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Mon, 5 Sep 2022 09:43:53 +0100
Subject: [PATCH 74/81] Update src/stores/room-list/SlidingRoomListStore.ts

Co-authored-by: Travis Ralston <travisr@matrix.org>
---
 src/stores/room-list/SlidingRoomListStore.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index ddcaf7f8618..16d7b81f3b7 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -82,7 +82,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     private counts: Record<TagID, number> = {};
     private stickyRoomId: string | null;
 
-    constructor() {
+    public constructor() {
         super(defaultDispatcher);
         this.setMaxListeners(20); // RoomList + LeftPanel + 8xRoomSubList + spares
     }

From c2598aaec114922f30cc286adb3c1f0d7ccd9de4 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 5 Sep 2022 09:47:56 +0100
Subject: [PATCH 75/81] Review comments

---
 src/SdkConfig.ts          | 2 --
 src/SlidingSyncManager.ts | 6 +++---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/SdkConfig.ts b/src/SdkConfig.ts
index 51feb9a6970..93b89a92eac 100644
--- a/src/SdkConfig.ts
+++ b/src/SdkConfig.ts
@@ -27,8 +27,6 @@ export const DEFAULTS: IConfigOptions = {
     integrations_ui_url: "https://scalar.vector.im/",
     integrations_rest_url: "https://scalar.vector.im/api",
     bug_report_endpoint_url: null,
-
-    // Jitsi conference options
     jitsi: {
         preferred_domain: "meet.element.io",
     },
diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 7b7cb633402..791cc36dc78 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -73,9 +73,9 @@ export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[
  * sync options and code.
  */
 export class SlidingSyncManager {
-    public static ListSpaces = "space_list";
-    public static ListSearch = "search_list";
-    private static internalInstance = new SlidingSyncManager();
+    public static readonly ListSpaces = "space_list";
+    public static readonly ListSearch = "search_list";
+    private static readonly internalInstance = new SlidingSyncManager();
 
     public slidingSync: SlidingSync;
     private client: MatrixClient;

From a1f14a8751e8ed2e03e73150e84712968aa5f749 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 5 Sep 2022 10:03:27 +0100
Subject: [PATCH 76/81] Add issue link for TODO markers

---
 src/Unread.ts                                | 1 +
 src/stores/room-list/SlidingRoomListStore.ts | 8 ++++----
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/Unread.ts b/src/Unread.ts
index 4eb178c4f61..b9b3409c66c 100644
--- a/src/Unread.ts
+++ b/src/Unread.ts
@@ -56,6 +56,7 @@ export function eventTriggersUnreadCount(ev: MatrixEvent): boolean {
 
 export function doesRoomHaveUnreadMessages(room: Room): boolean {
     if (SettingsStore.getValue("feature_sliding_sync")) {
+        // TODO: https://github.com/vector-im/element-web/issues/23207
         // Sliding Sync doesn't support unread indicator dots (yet...)
         return false;
     }
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index 16d7b81f3b7..a06d3cd22e8 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -49,7 +49,7 @@ const filterConditions: Record<TagID, MSC3575Filter> = {
         tags: ["m.favourite"],
         is_tombstoned: false,
     },
-    // TODO
+    // TODO https://github.com/vector-im/element-web/issues/23207
     // DefaultTagID.SavedItems,
     [DefaultTagID.DM]: {
         is_dm: true,
@@ -68,7 +68,7 @@ const filterConditions: Record<TagID, MSC3575Filter> = {
         tags: ["m.lowpriority"],
         is_tombstoned: false,
     },
-    // TODO
+    // TODO https://github.com/vector-im/element-web/issues/23207
     // DefaultTagID.ServerNotice,
     // DefaultTagID.Suggested,
     // DefaultTagID.Archived,
@@ -128,11 +128,11 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     public setListOrder(tagId: TagID, order: ListAlgorithm) {
-        // TODO?
+        // TODO: https://github.com/vector-im/element-web/issues/23207
     }
 
     public getListOrder(tagId: TagID): ListAlgorithm {
-        // TODO: handle unread msgs first?
+        // TODO: handle unread msgs first? https://github.com/vector-im/element-web/issues/23207
         return ListAlgorithm.Natural;
     }
 

From 3ebb9a1c9716b7992911a14e352078956ff2bc31 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Mon, 5 Sep 2022 10:36:15 +0100
Subject: [PATCH 77/81] Linting

---
 src/SlidingSyncManager.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 791cc36dc78..b2198dff87b 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -48,7 +48,7 @@ import { MatrixClient } from 'matrix-js-sdk/src/matrix';
 import { EventType } from 'matrix-js-sdk/src/@types/event';
 import {
     MSC3575Filter,
-    MSC3575List, 
+    MSC3575List,
     SlidingSync,
 } from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";

From 002e00eca3569549ece7251e3201deef74ee818b Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Wed, 7 Sep 2022 08:22:47 +0100
Subject: [PATCH 78/81] Apply suggestions from code review

Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>
---
 src/SlidingSyncManager.ts | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index b2198dff87b..a96fc116604 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -64,7 +64,11 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
     ],
 };
 
-export type PartialSlidingSyncRequest ={ filters?: MSC3575Filter, sort?: string[], ranges?: number[][] };
+export type PartialSlidingSyncRequest = {
+    filters?: MSC3575Filter;
+    sort?: string[];
+    ranges?: number[][];
+};
 
 /**
  * This class manages the entirety of sliding sync at a high UI/UX level. It controls the placement
@@ -95,7 +99,7 @@ export class SlidingSyncManager {
         return SlidingSyncManager.internalInstance;
     }
 
-    public configure(client: MatrixClient, proxyUrl?: string): SlidingSync {
+    public configure(client: MatrixClient, proxyUrl: string): SlidingSync {
         this.client = client;
         this.listIdToIndex = {};
         this.slidingSync = new SlidingSync(
@@ -117,7 +121,7 @@ export class SlidingSyncManager {
                 [EventType.RoomCreate, ""], // for isSpaceRoom checks
                 [EventType.SpaceChild, "*"], // all space children
                 [EventType.SpaceParent, "*"], // all space parents
-                [EventType.RoomMember, this.client.getUserId()], // lets the client calculate that we are in fact in the room
+                [EventType.RoomMember, this.client.getUserId()!], // lets the client calculate that we are in fact in the room
             ],
             filters: {
                 room_types: ["m.space"],

From 6de02e215718361a727347d65eabfecf2a9e92c8 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 7 Sep 2022 08:25:57 +0100
Subject: [PATCH 79/81] More review comments

---
 src/components/views/rooms/RoomSublist.tsx   | 4 +---
 src/rageshake/submit-rageshake.ts            | 5 -----
 src/stores/room-list/SlidingRoomListStore.ts | 2 +-
 3 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/src/components/views/rooms/RoomSublist.tsx b/src/components/views/rooms/RoomSublist.tsx
index 2b3aeb0506d..9e890e9c219 100644
--- a/src/components/views/rooms/RoomSublist.tsx
+++ b/src/components/views/rooms/RoomSublist.tsx
@@ -127,9 +127,7 @@ export default class RoomSublist extends React.Component<IProps, IState> {
             isResizing: false,
             isExpanded: !this.layout.isCollapsed,
             height: 0, // to be fixed in a moment, we need `rooms` to calculate this.
-            rooms: (
-                arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || [])
-            ),
+            rooms: arrayFastClone(RoomListStore.instance.orderedLists[this.props.tagId] || []),
             roomsLoading: false,
         };
         // Why Object.assign() and not this.state.height? Because TypeScript says no.
diff --git a/src/rageshake/submit-rageshake.ts b/src/rageshake/submit-rageshake.ts
index e202f993504..53b8f78c984 100644
--- a/src/rageshake/submit-rageshake.ts
+++ b/src/rageshake/submit-rageshake.ts
@@ -137,11 +137,6 @@ async function collectBugReport(opts: IOpts = {}, gzipLogs = true) {
         body.append("lowBandwidth", "enabled");
     }
 
-    // if sliding sync mode is enabled, say so over rageshake, since it's a huge change and can cause issues
-    if (SettingsStore.getValue("feature_sliding_sync")) {
-        body.append("feature_sliding_sync", "enabled");
-    }
-
     // add storage persistence/quota information
     if (navigator.storage && navigator.storage.persisted) {
         try {
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index a06d3cd22e8..cd5fee6ebb3 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -167,7 +167,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
      */
     public getTagsForRoom(room: Room): TagID[] {
         // check all lists for each tag we know about and see if the room is there
-        const tags = [];
+        const tags: TagID[] = [];
         for (const tagId in this.tagIdToSortAlgo) {
             const index = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
             const { roomIndexToRoomId } = SlidingSyncManager.instance.slidingSync.getListData(index);

From 63334decbf54791503fee5c621502c608607acd2 Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 7 Sep 2022 09:58:06 +0100
Subject: [PATCH 80/81] More review comments

---
 src/SlidingSyncManager.ts                          | 14 ++++++--------
 .../views/dialogs/spotlight/SpotlightDialog.tsx    |  6 +++---
 src/hooks/useSlidingSyncRoomSearch.ts              |  1 -
 src/stores/room-list/SlidingRoomListStore.ts       |  9 ++++-----
 4 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index a96fc116604..175cf04b7e9 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -52,6 +52,7 @@ import {
     SlidingSync,
 } from 'matrix-js-sdk/src/sliding-sync';
 import { logger } from "matrix-js-sdk/src/logger";
+import { IDeferred, defer } from 'matrix-js-sdk/src/utils';
 
 // how long to long poll for
 const SLIDING_SYNC_TIMEOUT_MS = 20 * 1000;
@@ -85,14 +86,11 @@ export class SlidingSyncManager {
     private client: MatrixClient;
     private listIdToIndex: Record<string, number>;
 
-    private configurePromise: Promise<void>;
-    private configureResolve: Function;
+    private configureDefer: IDeferred<void>;
 
     public constructor() {
         this.listIdToIndex = {};
-        this.configurePromise = new Promise((resolve) => {
-            this.configureResolve = resolve;
-        });
+        this.configureDefer = defer<void>();
     }
 
     public static get instance(): SlidingSyncManager {
@@ -127,7 +125,7 @@ export class SlidingSyncManager {
                 room_types: ["m.space"],
             },
         });
-        this.configureResolve();
+        this.configureDefer.resolve();
         return this.slidingSync;
     }
 
@@ -172,7 +170,7 @@ export class SlidingSyncManager {
         listIndex: number, updateArgs: PartialSlidingSyncRequest,
     ): Promise<MSC3575List> {
         logger.debug("ensureListRegistered:::", listIndex, updateArgs);
-        await this.configurePromise;
+        await this.configureDefer.promise;
         let list = this.slidingSync.getList(listIndex);
         if (!list) {
             list = {
@@ -215,7 +213,7 @@ export class SlidingSyncManager {
     }
 
     public async setRoomVisible(roomId: string, visible: boolean): Promise<string> {
-        await this.configurePromise;
+        await this.configureDefer.promise;
         const subscriptions = this.slidingSync.getRoomSubscriptions();
         if (visible) {
             subscriptions.add(roomId);
diff --git a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
index f5858db4bd2..95d945aa2ef 100644
--- a/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
+++ b/src/components/views/dialogs/spotlight/SpotlightDialog.tsx
@@ -354,9 +354,9 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", initialFilter = n
 
     const possibleResults = useMemo<Result[]>(
         () => {
-            const userResults = [];
-            let roomResults;
-            let alreadyAddedUserIds;
+            const userResults: IMemberResult[] = [];
+            let roomResults: IRoomResult[];
+            let alreadyAddedUserIds: Set<string>;
             if (isSlidingSyncEnabled) {
                 // use the rooms sliding sync returned as the server has already worked it out for us
                 roomResults = slidingSyncRooms.map(toRoomResult);
diff --git a/src/hooks/useSlidingSyncRoomSearch.ts b/src/hooks/useSlidingSyncRoomSearch.ts
index 93775f1baee..6ba08dc1a7c 100644
--- a/src/hooks/useSlidingSyncRoomSearch.ts
+++ b/src/hooks/useSlidingSyncRoomSearch.ts
@@ -79,7 +79,6 @@ export const useSlidingSyncRoomSearch = () => {
     }, [updateQuery, updateResult, listIndex]);
 
     return {
-        ready: true,
         loading,
         rooms,
         search,
diff --git a/src/stores/room-list/SlidingRoomListStore.ts b/src/stores/room-list/SlidingRoomListStore.ts
index cd5fee6ebb3..ccf4946886d 100644
--- a/src/stores/room-list/SlidingRoomListStore.ts
+++ b/src/stores/room-list/SlidingRoomListStore.ts
@@ -88,7 +88,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     public async setTagSorting(tagId: TagID, sort: SortAlgorithm) {
-        console.log("SlidingRoomListStore.setTagSorting ", tagId, sort);
+        logger.info("SlidingRoomListStore.setTagSorting ", tagId, sort);
         this.tagIdToSortAlgo[tagId] = sort;
         const slidingSyncIndex = SlidingSyncManager.instance.getOrAllocateListIndex(tagId);
         switch (sort) {
@@ -179,7 +179,6 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
                 }
             }
         }
-        console.log("SlidingRoomListStore.getTagsForRoom ", room.roomId, " => ", tags);
         return tags;
     }
 
@@ -307,7 +306,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     protected async onReady(): Promise<any> {
-        console.log("SlidingRoomListStore.onReady");
+        logger.info("SlidingRoomListStore.onReady");
         // permanent listeners: never get destroyed. Could be an issue if we want to test this in isolation.
         SlidingSyncManager.instance.slidingSync.on(SlidingSyncEvent.List, this.onSlidingSyncListUpdate.bind(this));
         RoomViewStore.instance.addListener(this.onRoomViewStoreUpdated.bind(this));
@@ -322,7 +321,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
         OrderedDefaultTagIDs.forEach((tagId) => {
             const filter = filterConditions[tagId];
             if (!filter) {
-                console.log("SlidingRoomListStore.onReady unsupported list ", tagId);
+                logger.info("SlidingRoomListStore.onReady unsupported list ", tagId);
                 return; // we do not support this list yet.
             }
             const sort = SortAlgorithm.Recent; // default to recency sort, TODO: read from config
@@ -339,7 +338,7 @@ export class SlidingRoomListStoreClass extends AsyncStoreWithClient<IState> impl
     }
 
     private onSelectedSpaceUpdated = (activeSpace: SpaceKey, allRoomsInHome: boolean) => {
-        console.log("SlidingRoomListStore.onSelectedSpaceUpdated", activeSpace);
+        logger.info("SlidingRoomListStore.onSelectedSpaceUpdated", activeSpace);
         // update the untagged filter
         const tagId = DefaultTagID.Untagged;
         const filters = filterConditions[tagId];

From f9a8cfb4790f52c66b2c99da7bad742762a2c91a Mon Sep 17 00:00:00 2001
From: Kegan Dougal <kegan@matrix.org>
Date: Wed, 7 Sep 2022 10:58:52 +0100
Subject: [PATCH 81/81] stricter types

---
 src/SlidingSyncManager.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/SlidingSyncManager.ts b/src/SlidingSyncManager.ts
index 175cf04b7e9..0e5736465ea 100644
--- a/src/SlidingSyncManager.ts
+++ b/src/SlidingSyncManager.ts
@@ -68,7 +68,7 @@ const DEFAULT_ROOM_SUBSCRIPTION_INFO = {
 export type PartialSlidingSyncRequest = {
     filters?: MSC3575Filter;
     sort?: string[];
-    ranges?: number[][];
+    ranges?: [startIndex: number, endIndex: number][];
 };
 
 /**