simplify 2

frontend/test-support/protocol-audit.test.ts

@@ -63,8 +63,7 @@ test(
                             JSON.stringify({
                                 type: "handshake",
                                 token,
-                                deviceId: randomUUID(),
-                                lastSeenVaultUpdateId: 0
+                                deviceId: randomUUID()
                             })
                         );
                     ws.onmessage = () => resolve(true);
@@ -302,8 +301,7 @@ test(
                             JSON.stringify({
                                 type: "handshake",
                                 token,
-                                deviceId,
-                                lastSeenVaultUpdateId: 0
+                                deviceId
                             })
                         );
                     ws.onmessage = () => resolve();

frontend/test-support/protocol.test.ts

@@ -282,7 +282,7 @@ for (const [kind, format, originalPath] of [
 }
 
 test(
-    "concurrent CAS commits have identical HTTP/event-log/WebSocket total order and reconnect catchup",
+    "WebSocket hints trigger HTTP catchup in commit order, including after reconnect",
     { timeout: 20_000 },
     async () => {
         const server = makeServer();
@@ -291,17 +291,29 @@ test(
             await server.start();
             const url = `${server.remoteUri}/vaults/order-${randomUUID()}`;
             const received: number[] = [];
-            const connect = async (after: number) => {
+            let catchup = Promise.resolve();
+            let catchupError: unknown;
+            const connect = async () => {
                 ws = new WebSocket(`${url.replace(/^http/, "ws")}/ws`);
                 ws.addEventListener("message", (message) => {
-                    const batch = JSON.parse(String(message.data)) as {
-                        type: string;
-                        events: { eventId: number }[];
-                    };
-                    if (batch.type === "vaultEvents")
-                        received.push(
-                            ...batch.events.map((event) => event.eventId)
-                        );
+                    const hint = JSON.parse(String(message.data));
+                    if (hint.type !== "vaultChanged") return;
+                    catchup = catchup
+                        .then(async () => {
+                            assert.deepEqual(hint, { type: "vaultChanged" });
+                            const batch = await getJson<{
+                                events: { eventId: number }[];
+                            }>(
+                                `${url}/events-since?after=${received.at(-1) ?? 0}`,
+                                token
+                            );
+                            received.push(
+                                ...batch.events.map((event) => event.eventId)
+                            );
+                        })
+                        .catch((error) => {
+                            catchupError = error;
+                        });
                 });
                 await new Promise<void>((resolve, reject) => {
                     ws!.onopen = () => resolve();
@@ -311,12 +323,11 @@ test(
                     JSON.stringify({
                         type: "handshake",
                         token,
-                        deviceId: "order-observer",
-                        lastSeenVaultUpdateId: after
+                        deviceId: "order-observer"
                     })
                 );
             };
-            await connect(0);
+            await connect();
             const ids = Array.from({ length: 12 }, () => randomUUID());
             const requests = ids.map((id, i) => ({
                 id,
@@ -360,10 +371,11 @@ test(
                 const deadline = Date.now() + 5_000;
                 while (received.length < head && Date.now() < deadline)
                     await new Promise((resolve) => setTimeout(resolve, 10));
+                if (catchupError) throw catchupError;
                 assert.deepEqual(
                     received,
                     Array.from({ length: head }, (_, i) => i + 1),
-                    "WebSocket reordered, lost or duplicated an event"
+                    "HTTP catchup after WebSocket hints lost or duplicated an event"
                 );
             };
             await waitForEvents(13);
@@ -375,7 +387,7 @@ test(
                 `${url}/documents/${ids[0]}`,
                 content("next", replies[0].vaultUpdateId)
             );
-            await connect(13);
+            await connect();
             await waitForEvents(14);
             const log = await getJson<{ events: { eventId: number }[] }>(
                 `${url}/events-since?after=0`,

frontend/test-support/sync-fixture.ts

@@ -11,7 +11,6 @@ import { Logger } from "../sync-client/src/tracing/logger";
 import { SyncHistory } from "../sync-client/src/tracing/sync-history";
 import { FixedSizeDocumentCache } from "../sync-client/src/utils/data-structures/fix-sized-cache";
 import { EventListeners } from "../sync-client/src/utils/data-structures/event-listeners";
-import { globsToRegexes } from "../sync-client/src/utils/globs-to-regexes";
 import type { ServerConfig } from "../sync-client/src/services/server-config";
 import type { SyncService } from "../sync-client/src/services/sync-service";
 import type { WebSocketManager } from "../sync-client/src/services/websocket-manager";
@@ -81,11 +80,7 @@ export async function fixture(
         config,
         undefined,
         { entries: () => changes, flush: async () => {} },
-        (path, size) =>
-            size > settings.getSettings().maxFileSizeMB * 1024 * 1024 ||
-            globsToRegexes(settings.getSettings().ignorePatterns, logger).some(
-                (pattern) => pattern.test(path)
-            )
+        (path, size) => settings.isIgnored(path) || settings.isOversized(size)
     );
     const websocket = {
         onWebSocketStatusChanged: new EventListeners(),