@powersync/service-core-tests 0.15.2 → 0.15.4

package/dist/tests/register-sync-tests.js

@@ -1,55 +1,3 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 import { createCoreAPIMetrics, JwtPayload, storage, sync, updateSyncRulesFromYaml } from '@powersync/service-core';
 import { JSONBig } from '@powersync/service-jsonbig';
 import path from 'path';
@@ -94,67 +42,53 @@ export function registerSyncTests(configOrFactory, options = {}) {
         }));
     };
     test('sync global data', async () => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_1, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
-            });
-            const bucketStorage = f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_1, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('0/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    description: 'Test 1'
-                },
-                afterReplicaId: 't1'
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't2',
-                    description: 'Test 2'
-                },
-                afterReplicaId: 't2'
-            });
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage: bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                isEncodingAsBson: false
-            });
-            const lines = await consumeCheckpointLines(stream);
-            expect(lines).toMatchSnapshot();
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
-        }
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                description: 'Test 1'
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't2',
+                description: 'Test 2'
+            },
+            afterReplicaId: 't2'
+        });
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage: bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        const lines = await consumeCheckpointLines(stream);
+        expect(lines).toMatchSnapshot();
     });
     test('sync buckets in order', async () => {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_2, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: `
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: `
 bucket_definitions:
   b0:
     priority: 2
@@ -165,62 +99,116 @@ bucket_definitions:
     data:
       - SELECT * FROM test WHERE LENGTH(id) > 2;
     `
-            });
-            const bucketStorage = f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_2, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('0/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    description: 'Test 1'
-                },
-                afterReplicaId: 't1'
-            });
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'earlier',
-                    description: 'Test 2'
-                },
-                afterReplicaId: 'earlier'
-            });
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                isEncodingAsBson: false
-            });
-            const lines = await consumeCheckpointLines(stream);
-            expect(lines).toMatchSnapshot();
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
-        }
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                description: 'Test 1'
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'earlier',
+                description: 'Test 2'
+            },
+            afterReplicaId: 'earlier'
+        });
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        const lines = await consumeCheckpointLines(stream);
+        expect(lines).toMatchSnapshot();
+    });
+    test('can override priority when subscribing to stream', async () => {
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: `
+config:
+  edition: 3
+
+streams:
+  todos:
+    query: SELECT * FROM test WHERE id IN subscription.parameter('test_ids')
+`
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'a',
+                description: 'Test 1'
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'b',
+                description: 'Test 2'
+            },
+            afterReplicaId: 'earlier'
+        });
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true,
+                streams: {
+                    include_defaults: true,
+                    subscriptions: [
+                        {
+                            stream: 'todos',
+                            parameters: { test_ids: ['a'] },
+                            override_priority: 0
+                        },
+                        {
+                            stream: 'todos',
+                            parameters: { test_ids: ['a', 'b'] },
+                            override_priority: null
+                        }
+                    ]
+                }
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        const lines = await consumeCheckpointLines(stream);
+        expect(lines).toMatchSnapshot();
     });
     test('sync interrupts low-priority buckets on new checkpoints', async () => {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_3, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: `
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: `
 bucket_definitions:
   b0:
     priority: 2
@@ -231,105 +219,93 @@ bucket_definitions:
     data:
       - SELECT * FROM test WHERE LENGTH(id) > 5;
     `
-            });
-            const bucketStorage = f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_3, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('0/1');
-            // Initial data: Add one priority row and 10k low-priority rows.
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        // Initial data: Add one priority row and 10k low-priority rows.
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'highprio',
+                description: 'High priority row'
+            },
+            afterReplicaId: 'highprio'
+        });
+        for (let i = 0; i < 10_000; i++) {
             await writer.save({
                 sourceTable: testTable,
                 tag: storage.SaveOperationTag.INSERT,
                 after: {
-                    id: 'highprio',
-                    description: 'High priority row'
+                    id: `${i}`,
+                    description: 'low prio'
                 },
-                afterReplicaId: 'highprio'
+                afterReplicaId: `${i}`
             });
-            for (let i = 0; i < 10_000; i++) {
-                await writer.save({
-                    sourceTable: testTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: `${i}`,
-                        description: 'low prio'
-                    },
-                    afterReplicaId: `${i}`
-                });
+        }
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        let sentCheckpoints = 0;
+        let sentRows = 0;
+        for await (let next of stream) {
+            if (typeof next == 'string') {
+                next = JSON.parse(next);
             }
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                isEncodingAsBson: false
-            });
-            let sentCheckpoints = 0;
-            let sentRows = 0;
-            for await (let next of stream) {
-                if (typeof next == 'string') {
-                    next = JSON.parse(next);
-                }
-                if (typeof next === 'object' && next !== null) {
-                    if ('partial_checkpoint_complete' in next) {
-                        if (sentCheckpoints == 1) {
-                            // Save new data to interrupt the low-priority sync.
-                            // Add another high-priority row. This should interrupt the long-running low-priority sync.
-                            await writer.save({
-                                sourceTable: testTable,
-                                tag: storage.SaveOperationTag.INSERT,
-                                after: {
-                                    id: 'highprio2',
-                                    description: 'Another high-priority row'
-                                },
-                                afterReplicaId: 'highprio2'
-                            });
-                            await writer.commit('0/2');
-                        }
-                        else {
-                            // Low-priority sync from the first checkpoint was interrupted. This should not happen before
-                            // 1000 low-priority items were synchronized.
-                            expect(sentCheckpoints).toBe(2);
-                            expect(sentRows).toBeGreaterThan(1000);
-                        }
+            if (typeof next === 'object' && next !== null) {
+                if ('partial_checkpoint_complete' in next) {
+                    if (sentCheckpoints == 1) {
+                        // Save new data to interrupt the low-priority sync.
+                        // Add another high-priority row. This should interrupt the long-running low-priority sync.
+                        await writer.save({
+                            sourceTable: testTable,
+                            tag: storage.SaveOperationTag.INSERT,
+                            after: {
+                                id: 'highprio2',
+                                description: 'Another high-priority row'
+                            },
+                            afterReplicaId: 'highprio2'
+                        });
+                        await writer.commit('0/2');
                     }
-                    if ('checkpoint' in next || 'checkpoint_diff' in next) {
-                        sentCheckpoints += 1;
-                    }
-                    if ('data' in next) {
-                        sentRows += next.data.data.length;
-                    }
-                    if ('checkpoint_complete' in next) {
-                        break;
+                    else {
+                        // Low-priority sync from the first checkpoint was interrupted. This should not happen before
+                        // 1000 low-priority items were synchronized.
+                        expect(sentCheckpoints).toBe(2);
+                        expect(sentRows).toBeGreaterThan(1000);
                     }
                 }
+                if ('checkpoint' in next || 'checkpoint_diff' in next) {
+                    sentCheckpoints += 1;
+                }
+                if ('data' in next) {
+                    sentRows += next.data.data.length;
+                }
+                if ('checkpoint_complete' in next) {
+                    break;
+                }
             }
-            expect(sentCheckpoints).toBe(2);
-            expect(sentRows).toBe(10002);
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            const result_3 = __disposeResources(env_3);
-            if (result_3)
-                await result_3;
         }
+        expect(sentCheckpoints).toBe(2);
+        expect(sentRows).toBe(10002);
     });
     test('sync interruptions with unrelated data', async () => {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_4, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: `
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: `
 bucket_definitions:
   b0:
     priority: 2
@@ -341,128 +317,116 @@ bucket_definitions:
     data:
       - SELECT * FROM test WHERE LENGTH(id) > 5 AND description = bucket.user_id;
     `
-            });
-            const bucketStorage = f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_4, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('0/1');
-            // Initial data: Add one priority row and 10k low-priority rows.
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        // Initial data: Add one priority row and 10k low-priority rows.
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'highprio',
+                description: 'user_one'
+            },
+            afterReplicaId: 'highprio'
+        });
+        for (let i = 0; i < 10_000; i++) {
             await writer.save({
                 sourceTable: testTable,
                 tag: storage.SaveOperationTag.INSERT,
                 after: {
-                    id: 'highprio',
-                    description: 'user_one'
+                    id: `${i}`,
+                    description: 'low prio'
                 },
-                afterReplicaId: 'highprio'
+                afterReplicaId: `${i}`
             });
-            for (let i = 0; i < 10_000; i++) {
-                await writer.save({
-                    sourceTable: testTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: `${i}`,
-                        description: 'low prio'
-                    },
-                    afterReplicaId: `${i}`
-                });
+        }
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: 'user_one', exp: Date.now() / 1000 + 100000 }),
+            isEncodingAsBson: false
+        });
+        let sentCheckpoints = 0;
+        let completedCheckpoints = 0;
+        let sentRows = 0;
+        // Expected flow:
+        //  1. Stream starts, we receive a checkpoint followed by the one high-prio row and a partial completion.
+        //  2. We insert a new row that is not part of a bucket relevant to this stream.
+        //  3. This means that no interruption happens and we receive all the low-priority data, followed by a checkpoint.
+        //  4. After the checkpoint, add a new row that _is_ relevant for this sync, which should trigger a new iteration.
+        for await (let next of stream) {
+            if (typeof next == 'string') {
+                next = JSON.parse(next);
             }
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: 'user_one', exp: Date.now() / 1000 + 100000 }),
-                isEncodingAsBson: false
-            });
-            let sentCheckpoints = 0;
-            let completedCheckpoints = 0;
-            let sentRows = 0;
-            // Expected flow:
-            //  1. Stream starts, we receive a checkpoint followed by the one high-prio row and a partial completion.
-            //  2. We insert a new row that is not part of a bucket relevant to this stream.
-            //  3. This means that no interruption happens and we receive all the low-priority data, followed by a checkpoint.
-            //  4. After the checkpoint, add a new row that _is_ relevant for this sync, which should trigger a new iteration.
-            for await (let next of stream) {
-                if (typeof next == 'string') {
-                    next = JSON.parse(next);
-                }
-                if (typeof next === 'object' && next !== null) {
-                    if ('partial_checkpoint_complete' in next) {
-                        if (sentCheckpoints == 1) {
-                            // Add a high-priority row that doesn't affect this sync stream.
-                            await writer.save({
-                                sourceTable: testTable,
-                                tag: storage.SaveOperationTag.INSERT,
-                                after: {
-                                    id: 'highprio2',
-                                    description: 'user_two'
-                                },
-                                afterReplicaId: 'highprio2'
-                            });
-                            await writer.commit('0/2');
-                        }
-                        else {
-                            expect(sentCheckpoints).toBe(2);
-                            expect(sentRows).toBe(10002);
-                        }
+            if (typeof next === 'object' && next !== null) {
+                if ('partial_checkpoint_complete' in next) {
+                    if (sentCheckpoints == 1) {
+                        // Add a high-priority row that doesn't affect this sync stream.
+                        await writer.save({
+                            sourceTable: testTable,
+                            tag: storage.SaveOperationTag.INSERT,
+                            after: {
+                                id: 'highprio2',
+                                description: 'user_two'
+                            },
+                            afterReplicaId: 'highprio2'
+                        });
+                        await writer.commit('0/2');
                     }
-                    if ('checkpoint' in next || 'checkpoint_diff' in next) {
-                        sentCheckpoints += 1;
+                    else {
+                        expect(sentCheckpoints).toBe(2);
+                        expect(sentRows).toBe(10002);
                     }
-                    if ('data' in next) {
-                        sentRows += next.data.data.length;
+                }
+                if ('checkpoint' in next || 'checkpoint_diff' in next) {
+                    sentCheckpoints += 1;
+                }
+                if ('data' in next) {
+                    sentRows += next.data.data.length;
+                }
+                if ('checkpoint_complete' in next) {
+                    completedCheckpoints++;
+                    if (completedCheckpoints == 2) {
+                        break;
                     }
-                    if ('checkpoint_complete' in next) {
-                        completedCheckpoints++;
-                        if (completedCheckpoints == 2) {
-                            break;
-                        }
-                        if (completedCheckpoints == 1) {
-                            expect(sentRows).toBe(10001);
-                            // Add a high-priority row that affects this sync stream.
-                            await writer.save({
-                                sourceTable: testTable,
-                                tag: storage.SaveOperationTag.INSERT,
-                                after: {
-                                    id: 'highprio3',
-                                    description: 'user_one'
-                                },
-                                afterReplicaId: 'highprio3'
-                            });
-                            await writer.commit('0/3');
-                        }
+                    if (completedCheckpoints == 1) {
+                        expect(sentRows).toBe(10001);
+                        // Add a high-priority row that affects this sync stream.
+                        await writer.save({
+                            sourceTable: testTable,
+                            tag: storage.SaveOperationTag.INSERT,
+                            after: {
+                                id: 'highprio3',
+                                description: 'user_one'
+                            },
+                            afterReplicaId: 'highprio3'
+                        });
+                        await writer.commit('0/3');
                     }
                 }
             }
-            expect(sentCheckpoints).toBe(2);
-            expect(sentRows).toBe(10002);
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            const result_4 = __disposeResources(env_4);
-            if (result_4)
-                await result_4;
         }
+        expect(sentCheckpoints).toBe(2);
+        expect(sentRows).toBe(10002);
     });
     test('sync interrupts low-priority buckets on new checkpoints (2)', async () => {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_5, await factory(), true);
-            // bucket0a -> send all data
-            // then interrupt checkpoint with new data for all buckets
-            // -> data for all buckets should be sent in the new checkpoint
-            const syncRules = await updateSyncRules(f, {
-                content: `
+        await using f = await factory();
+        // bucket0a -> send all data
+        // then interrupt checkpoint with new data for all buckets
+        // -> data for all buckets should be sent in the new checkpoint
+        const syncRules = await updateSyncRules(f, {
+            content: `
 bucket_definitions:
   b0a:
     priority: 2
@@ -477,613 +441,701 @@ bucket_definitions:
     data:
       - SELECT * FROM test WHERE LENGTH(id) > 5;
     `
-            });
-            const bucketStorage = f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_5, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('0/1');
-            // Initial data: Add one priority row and 10k low-priority rows.
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        // Initial data: Add one priority row and 10k low-priority rows.
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'highprio',
+                description: 'High priority row'
+            },
+            afterReplicaId: 'highprio'
+        });
+        for (let i = 0; i < 2_000; i++) {
             await writer.save({
                 sourceTable: testTable,
                 tag: storage.SaveOperationTag.INSERT,
                 after: {
-                    id: 'highprio',
-                    description: 'High priority row'
+                    id: `${i}`,
+                    description: 'low prio'
                 },
-                afterReplicaId: 'highprio'
+                afterReplicaId: `${i}`
             });
-            for (let i = 0; i < 2_000; i++) {
-                await writer.save({
-                    sourceTable: testTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: `${i}`,
-                        description: 'low prio'
-                    },
-                    afterReplicaId: `${i}`
-                });
+        }
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        let sentRows = 0;
+        let lines = [];
+        for await (let next of stream) {
+            if (typeof next == 'string') {
+                next = JSON.parse(next);
             }
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                isEncodingAsBson: false
-            });
-            let sentRows = 0;
-            let lines = [];
-            for await (let next of stream) {
-                if (typeof next == 'string') {
-                    next = JSON.parse(next);
+            if (typeof next === 'object' && next !== null) {
+                if ('partial_checkpoint_complete' in next) {
+                    lines.push(next);
                 }
-                if (typeof next === 'object' && next !== null) {
-                    if ('partial_checkpoint_complete' in next) {
-                        lines.push(next);
-                    }
-                    if ('checkpoint' in next || 'checkpoint_diff' in next) {
-                        lines.push(next);
+                if ('checkpoint' in next || 'checkpoint_diff' in next) {
+                    lines.push(next);
+                }
+                if ('data' in next) {
+                    lines.push({ data: { ...next.data, data: undefined } });
+                    sentRows += next.data.data.length;
+                    if (sentRows == 1001) {
+                        // Save new data to interrupt the low-priority sync.
+                        // Add another high-priority row. This should interrupt the long-running low-priority sync.
+                        await writer.save({
+                            sourceTable: testTable,
+                            tag: storage.SaveOperationTag.INSERT,
+                            after: {
+                                id: 'highprio2',
+                                description: 'Another high-priority row'
+                            },
+                            afterReplicaId: 'highprio2'
+                        });
+                        // Also add a low-priority row
+                        await writer.save({
+                            sourceTable: testTable,
+                            tag: storage.SaveOperationTag.INSERT,
+                            after: {
+                                id: '2001',
+                                description: 'Another low-priority row'
+                            },
+                            afterReplicaId: '2001'
+                        });
+                        await writer.commit('0/2');
                     }
-                    if ('data' in next) {
-                        lines.push({ data: { ...next.data, data: undefined } });
-                        sentRows += next.data.data.length;
-                        if (sentRows == 1001) {
-                            // Save new data to interrupt the low-priority sync.
-                            // Add another high-priority row. This should interrupt the long-running low-priority sync.
-                            await writer.save({
-                                sourceTable: testTable,
-                                tag: storage.SaveOperationTag.INSERT,
-                                after: {
-                                    id: 'highprio2',
-                                    description: 'Another high-priority row'
-                                },
-                                afterReplicaId: 'highprio2'
-                            });
-                            // Also add a low-priority row
-                            await writer.save({
-                                sourceTable: testTable,
-                                tag: storage.SaveOperationTag.INSERT,
-                                after: {
-                                    id: '2001',
-                                    description: 'Another low-priority row'
-                                },
-                                afterReplicaId: '2001'
-                            });
-                            await writer.commit('0/2');
-                        }
-                        if (sentRows >= 1000 && sentRows <= 2001) {
-                            // pause for a bit to give the stream time to process interruptions.
-                            // This covers the data batch above and the next one.
-                            await timers.setTimeout(50);
-                        }
-                    }
-                    if ('checkpoint_complete' in next) {
-                        lines.push(next);
-                        break;
+                    if (sentRows >= 1000 && sentRows <= 2001) {
+                        // pause for a bit to give the stream time to process interruptions.
+                        // This covers the data batch above and the next one.
+                        await timers.setTimeout(50);
                     }
                 }
+                if ('checkpoint_complete' in next) {
+                    lines.push(next);
+                    break;
+                }
             }
-            // Expected lines (full details in snapshot):
-            //
-            // checkpoint (4001)
-            // data (b1[] 0 -> 1)
-            // partial_checkpoint_complete (4001, priority 1)
-            // data (b0a[], 0 -> 2000)
-            // ## adds new data, interrupting the checkpoint
-            // data (b0a[], 2000 -> 4000) # expected - stream is already busy with this by the time it receives the interruption
-            // checkpoint_diff (4004)
-            // data (b1[], 1 -> 4002)
-            // partial_checkpoint_complete (4004, priority 1)
-            // data (b0a[], 4000 -> 4003)
-            // data (b0b[], 0 -> 1999)
-            // data (b0b[], 1999 -> 3999)
-            // data (b0b[], 3999 -> 4004)
-            // checkpoint_complete (4004)
-            expect(lines).toMatchSnapshot();
-            expect(sentRows).toBe(4004);
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            const result_5 = __disposeResources(env_5);
-            if (result_5)
-                await result_5;
         }
+        // Expected lines (full details in snapshot):
+        //
+        // checkpoint (4001)
+        // data (b1[] 0 -> 1)
+        // partial_checkpoint_complete (4001, priority 1)
+        // data (b0a[], 0 -> 2000)
+        // ## adds new data, interrupting the checkpoint
+        // data (b0a[], 2000 -> 4000) # expected - stream is already busy with this by the time it receives the interruption
+        // checkpoint_diff (4004)
+        // data (b1[], 1 -> 4002)
+        // partial_checkpoint_complete (4004, priority 1)
+        // data (b0a[], 4000 -> 4003)
+        // data (b0b[], 0 -> 1999)
+        // data (b0b[], 1999 -> 3999)
+        // data (b0b[], 3999 -> 4004)
+        // checkpoint_complete (4004)
+        expect(lines).toMatchSnapshot();
+        expect(sentRows).toBe(4004);
     });
     test('sends checkpoint complete line for empty checkpoint', async () => {
-        const env_6 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_6, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
-            });
-            const bucketStorage = f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_6, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('0/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    description: 'sync'
-                },
-                afterReplicaId: 't1'
-            });
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 100000 }),
-                isEncodingAsBson: false
-            });
-            const lines = [];
-            let receivedCompletions = 0;
-            for await (let next of stream) {
-                if (typeof next == 'string') {
-                    next = JSON.parse(next);
-                }
-                lines.push(next);
-                if (typeof next === 'object' && next !== null) {
-                    if ('checkpoint_complete' in next) {
-                        receivedCompletions++;
-                        if (receivedCompletions == 1) {
-                            // Trigger an empty bucket update.
-                            await bucketStorage.createManagedWriteCheckpoint({ user_id: '', heads: { '1': '1/0' } });
-                            await writer.commit('1/0');
-                        }
-                        else {
-                            break;
-                        }
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                description: 'sync'
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 100000 }),
+            isEncodingAsBson: false
+        });
+        const lines = [];
+        let receivedCompletions = 0;
+        for await (let next of stream) {
+            if (typeof next == 'string') {
+                next = JSON.parse(next);
+            }
+            lines.push(next);
+            if (typeof next === 'object' && next !== null) {
+                if ('checkpoint_complete' in next) {
+                    receivedCompletions++;
+                    if (receivedCompletions == 1) {
+                        // Trigger an empty bucket update.
+                        await bucketStorage.createManagedWriteCheckpoint({ user_id: '', heads: { '1': '1/0' } });
+                        await writer.commit('1/0');
+                    }
+                    else {
+                        break;
                     }
                 }
             }
-            expect(lines).toMatchSnapshot();
-        }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
-        }
-        finally {
-            const result_6 = __disposeResources(env_6);
-            if (result_6)
-                await result_6;
         }
+        expect(lines).toMatchSnapshot();
     });
     test('sync legacy non-raw data', async () => {
-        const env_7 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_7, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
-            });
-            const bucketStorage = await f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_7, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('0/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    description: 'Test\n"string"',
-                    large_num: 12345678901234567890n
-                },
-                afterReplicaId: 't1'
-            });
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: false
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                isEncodingAsBson: false
-            });
-            const lines = await consumeCheckpointLines(stream);
-            expect(lines).toMatchSnapshot();
-            // Specifically check the number - this is the important part of the test
-            expect(lines[1].data.data[0].data.large_num).toEqual(12345678901234567890n);
-        }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
-        }
-        finally {
-            const result_7 = __disposeResources(env_7);
-            if (result_7)
-                await result_7;
-        }
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                description: 'Test\n"string"',
+                large_num: 12345678901234567890n
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: false
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        const lines = await consumeCheckpointLines(stream);
+        expect(lines).toMatchSnapshot();
+        // Specifically check the number - this is the important part of the test
+        expect(lines[1].data.data[0].data.large_num).toEqual(12345678901234567890n);
     });
     test('expired token', async () => {
-        const env_8 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_8, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
-            });
-            const bucketStorage = await f.getInstance(syncRules);
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: 0 }),
-                isEncodingAsBson: false
-            });
-            const lines = await consumeCheckpointLines(stream);
-            expect(lines).toMatchSnapshot();
-        }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
-        }
-        finally {
-            const result_8 = __disposeResources(env_8);
-            if (result_8)
-                await result_8;
-        }
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: 0 }),
+            isEncodingAsBson: false
+        });
+        const lines = await consumeCheckpointLines(stream);
+        expect(lines).toMatchSnapshot();
     });
     test('sync updates to global data', async (context) => {
-        const env_9 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_9, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
-            });
-            const bucketStorage = await f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_9, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            // Activate
-            await writer.markAllSnapshotDone('0/0');
-            await writer.keepalive('0/0');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                isEncodingAsBson: false
-            });
-            const iter = stream[Symbol.asyncIterator]();
-            context.onTestFinished(() => {
-                iter.return?.();
-            });
-            expect(await getCheckpointLines(iter)).toMatchSnapshot();
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    description: 'Test 1'
-                },
-                afterReplicaId: 't1'
-            });
-            await writer.commit('0/1');
-            expect(await getCheckpointLines(iter)).toMatchSnapshot();
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't2',
-                    description: 'Test 2'
-                },
-                afterReplicaId: 't2'
-            });
-            await writer.commit('0/2');
-            expect(await getCheckpointLines(iter)).toMatchSnapshot();
-        }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
-        }
-        finally {
-            const result_9 = __disposeResources(env_9);
-            if (result_9)
-                await result_9;
-        }
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        // Activate
+        await writer.markAllSnapshotDone('0/0');
+        await writer.keepalive('0/0');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        const iter = stream[Symbol.asyncIterator]();
+        context.onTestFinished(() => {
+            iter.return?.();
+        });
+        expect(await getCheckpointLines(iter)).toMatchSnapshot();
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                description: 'Test 1'
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.commit('0/1');
+        expect(await getCheckpointLines(iter)).toMatchSnapshot();
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't2',
+                description: 'Test 2'
+            },
+            afterReplicaId: 't2'
+        });
+        await writer.commit('0/2');
+        expect(await getCheckpointLines(iter)).toMatchSnapshot();
     });
     test('sync updates to parameter query only', async (context) => {
-        const env_10 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_10, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: `bucket_definitions:
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: `bucket_definitions:
   by_user:
     parameters: select users.id as user_id from users where users.id = request.user_id()
     data:
       - select * from lists where user_id = bucket.user_id
 `
-            });
-            const bucketStorage = await f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_10, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
-            // Activate
-            await writer.markAllSnapshotDone('0/0');
-            await writer.keepalive('0/0');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: 'user1', exp: Date.now() / 1000 + 100 }),
-                isEncodingAsBson: false
-            });
-            const iter = stream[Symbol.asyncIterator]();
-            context.onTestFinished(() => {
-                iter.return?.();
-            });
-            // Initial empty checkpoint
-            const checkpoint1 = await getCheckpointLines(iter);
-            expect(checkpoint1[0].checkpoint?.buckets?.map((b) => b.bucket)).toEqual([]);
-            expect(checkpoint1).toMatchSnapshot();
-            // Add user
-            await writer.save({
-                sourceTable: usersTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'user1',
-                    name: 'User 1'
-                },
-                afterReplicaId: 'user1'
-            });
-            await writer.commit('0/1');
-            const checkpoint2 = await getCheckpointLines(iter);
-            const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
-            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
-            expect(checkpoint2).toMatchSnapshot();
-        }
-        catch (e_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
-        }
-        finally {
-            const result_10 = __disposeResources(env_10);
-            if (result_10)
-                await result_10;
-        }
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
+        // Activate
+        await writer.markAllSnapshotDone('0/0');
+        await writer.keepalive('0/0');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: 'user1', exp: Date.now() / 1000 + 100 }),
+            isEncodingAsBson: false
+        });
+        const iter = stream[Symbol.asyncIterator]();
+        context.onTestFinished(() => {
+            iter.return?.();
+        });
+        // Initial empty checkpoint
+        const checkpoint1 = await getCheckpointLines(iter);
+        expect(checkpoint1[0].checkpoint?.buckets?.map((b) => b.bucket)).toEqual([]);
+        expect(checkpoint1).toMatchSnapshot();
+        // Add user
+        await writer.save({
+            sourceTable: usersTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'user1',
+                name: 'User 1'
+            },
+            afterReplicaId: 'user1'
+        });
+        await writer.commit('0/1');
+        const checkpoint2 = await getCheckpointLines(iter);
+        const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
+        expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
+        expect(checkpoint2).toMatchSnapshot();
     });
     test('sync updates to data query only', async (context) => {
-        const env_11 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_11, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: `bucket_definitions:
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: `bucket_definitions:
   by_user:
     parameters: select users.id as user_id from users where users.id = request.user_id()
     data:
       - select * from lists where user_id = bucket.user_id
 `
-            });
-            const bucketStorage = await f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_11, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
-            const listsTable = await test_utils.resolveTestTable(writer, 'lists', ['id'], config, 2);
-            await writer.markAllSnapshotDone('0/1');
-            await writer.save({
-                sourceTable: usersTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'user1',
-                    name: 'User 1'
-                },
-                afterReplicaId: 'user1'
-            });
-            await writer.commit('0/1');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: 'user1', exp: Date.now() / 1000 + 100 }),
-                isEncodingAsBson: false
-            });
-            const iter = stream[Symbol.asyncIterator]();
-            context.onTestFinished(() => {
-                iter.return?.();
-            });
-            const { bucket } = bucketRequest(syncRules, 'by_user["user1"]');
-            const checkpoint1 = await getCheckpointLines(iter);
-            expect(checkpoint1[0].checkpoint?.buckets?.map((b) => b.bucket)).toEqual([bucket]);
-            expect(checkpoint1).toMatchSnapshot();
-            await writer.save({
-                sourceTable: listsTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'list1',
-                    user_id: 'user1',
-                    name: 'User 1'
-                },
-                afterReplicaId: 'list1'
-            });
-            await writer.commit('0/1');
-            const checkpoint2 = await getCheckpointLines(iter);
-            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
-            expect(checkpoint2).toMatchSnapshot();
-        }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
-        }
-        finally {
-            const result_11 = __disposeResources(env_11);
-            if (result_11)
-                await result_11;
-        }
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
+        const listsTable = await test_utils.resolveTestTable(writer, 'lists', ['id'], config, 2);
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: usersTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'user1',
+                name: 'User 1'
+            },
+            afterReplicaId: 'user1'
+        });
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: 'user1', exp: Date.now() / 1000 + 100 }),
+            isEncodingAsBson: false
+        });
+        const iter = stream[Symbol.asyncIterator]();
+        context.onTestFinished(() => {
+            iter.return?.();
+        });
+        const { bucket } = bucketRequest(syncRules, 'by_user["user1"]');
+        const checkpoint1 = await getCheckpointLines(iter);
+        expect(checkpoint1[0].checkpoint?.buckets?.map((b) => b.bucket)).toEqual([bucket]);
+        expect(checkpoint1).toMatchSnapshot();
+        await writer.save({
+            sourceTable: listsTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'list1',
+                user_id: 'user1',
+                name: 'User 1'
+            },
+            afterReplicaId: 'list1'
+        });
+        await writer.commit('0/1');
+        const checkpoint2 = await getCheckpointLines(iter);
+        expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
+        expect(checkpoint2).toMatchSnapshot();
     });
     test('sync updates to parameter query + data', async (context) => {
-        const env_12 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_12, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: `bucket_definitions:
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: `bucket_definitions:
   by_user:
     parameters: select users.id as user_id from users where users.id = request.user_id()
     data:
       - select * from lists where user_id = bucket.user_id
 `
-            });
-            const bucketStorage = await f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_12, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
-            const listsTable = await test_utils.resolveTestTable(writer, 'lists', ['id'], config, 2);
-            // Activate
-            await writer.markAllSnapshotDone('0/0');
-            await writer.keepalive('0/0');
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: 'user1', exp: Date.now() / 1000 + 100 }),
-                isEncodingAsBson: false
-            });
-            const iter = stream[Symbol.asyncIterator]();
-            context.onTestFinished(() => {
-                iter.return?.();
-            });
-            // Initial empty checkpoint
-            expect(await getCheckpointLines(iter)).toMatchSnapshot();
-            await writer.markAllSnapshotDone('0/1');
-            await writer.save({
-                sourceTable: listsTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'list1',
-                    user_id: 'user1',
-                    name: 'User 1'
-                },
-                afterReplicaId: 'list1'
-            });
-            await writer.save({
-                sourceTable: usersTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'user1',
-                    name: 'User 1'
-                },
-                afterReplicaId: 'user1'
-            });
-            await writer.commit('0/1');
-            const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
-            const checkpoint2 = await getCheckpointLines(iter);
-            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
-            expect(checkpoint2).toMatchSnapshot();
-        }
-        catch (e_12) {
-            env_12.error = e_12;
-            env_12.hasError = true;
-        }
-        finally {
-            const result_12 = __disposeResources(env_12);
-            if (result_12)
-                await result_12;
-        }
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
+        const listsTable = await test_utils.resolveTestTable(writer, 'lists', ['id'], config, 2);
+        // Activate
+        await writer.markAllSnapshotDone('0/0');
+        await writer.keepalive('0/0');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: 'user1', exp: Date.now() / 1000 + 100 }),
+            isEncodingAsBson: false
+        });
+        const iter = stream[Symbol.asyncIterator]();
+        context.onTestFinished(() => {
+            iter.return?.();
+        });
+        // Initial empty checkpoint
+        expect(await getCheckpointLines(iter)).toMatchSnapshot();
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: listsTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'list1',
+                user_id: 'user1',
+                name: 'User 1'
+            },
+            afterReplicaId: 'list1'
+        });
+        await writer.save({
+            sourceTable: usersTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'user1',
+                name: 'User 1'
+            },
+            afterReplicaId: 'user1'
+        });
+        await writer.commit('0/1');
+        const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
+        const checkpoint2 = await getCheckpointLines(iter);
+        expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
+        expect(checkpoint2).toMatchSnapshot();
     });
     test('expiring token', async (context) => {
-        const env_13 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_13, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
-            });
-            const bucketStorage = await f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_13, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            // Activate
-            await writer.markAllSnapshotDone('0/0');
-            await writer.keepalive('0/0');
-            const exp = Date.now() / 1000 + 0.1;
-            const stream = sync.streamResponse({
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: '', exp: exp }),
-                isEncodingAsBson: false
-            });
-            const iter = stream[Symbol.asyncIterator]();
-            context.onTestFinished(() => {
-                iter.return?.();
-            });
-            const checkpoint = await getCheckpointLines(iter);
-            expect(checkpoint).toMatchSnapshot();
-            const expLines = await getCheckpointLines(iter);
-            expect(expLines).toMatchSnapshot();
-        }
-        catch (e_13) {
-            env_13.error = e_13;
-            env_13.hasError = true;
-        }
-        finally {
-            const result_13 = __disposeResources(env_13);
-            if (result_13)
-                await result_13;
-        }
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        // Activate
+        await writer.markAllSnapshotDone('0/0');
+        await writer.keepalive('0/0');
+        const exp = Date.now() / 1000 + 0.1;
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: exp }),
+            isEncodingAsBson: false
+        });
+        const iter = stream[Symbol.asyncIterator]();
+        context.onTestFinished(() => {
+            iter.return?.();
+        });
+        const checkpoint = await getCheckpointLines(iter);
+        expect(checkpoint).toMatchSnapshot();
+        const expLines = await getCheckpointLines(iter);
+        expect(expLines).toMatchSnapshot();
     });
     test('compacting data - invalidate checkpoint', async (context) => {
-        const env_14 = { stack: [], error: void 0, hasError: false };
-        try {
-            // This tests a case of a compact operation invalidating a checkpoint in the
-            // middle of syncing data.
-            // This is expected to be rare in practice, but it is important to handle
-            // this case correctly to maintain consistency on the client.
-            const f = __addDisposableResource(env_14, await factory(), true);
+        // This tests a case of a compact operation invalidating a checkpoint in the
+        // middle of syncing data.
+        // This is expected to be rare in practice, but it is important to handle
+        // this case correctly to maintain consistency on the client.
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = await f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                description: 'Test 1'
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't2',
+                description: 'Test 2'
+            },
+            afterReplicaId: 't2'
+        });
+        await writer.commit('0/1');
+        const stream = sync.streamResponse({
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        });
+        const iter = stream[Symbol.asyncIterator]();
+        context.onTestFinished(() => {
+            iter.return?.();
+        });
+        // Only consume the first "checkpoint" message, and pause before receiving data.
+        const lines = await consumeIterator(iter, { consume: false, isDone: (line) => line?.checkpoint != null });
+        expect(lines).toMatchSnapshot();
+        expect(lines[0]).toEqual({
+            checkpoint: expect.objectContaining({
+                last_op_id: '2'
+            })
+        });
+        // Now we save additional data AND compact before continuing.
+        // This invalidates the checkpoint we've received above.
+        await writer.markAllSnapshotDone('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 't1',
+                description: 'Test 1b'
+            },
+            afterReplicaId: 't1'
+        });
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 't2',
+                description: 'Test 2b'
+            },
+            afterReplicaId: 't2'
+        });
+        await writer.commit('0/2');
+        await bucketStorage.compact({
+            minBucketChanges: 1,
+            minChangeRatio: 0
+        });
+        const lines2 = await getCheckpointLines(iter, { consume: true });
+        // Snapshot test checks for changes in general.
+        // The tests after that documents the specific things we're looking for
+        // in this test.
+        expect(lines2).toMatchSnapshot();
+        expect(lines2[0]).toEqual({
+            data: expect.objectContaining({
+                has_more: false,
+                data: [
+                    // The first two ops have been replaced by a single CLEAR op
+                    expect.objectContaining({
+                        op: 'CLEAR'
+                    })
+                ]
+            })
+        });
+        // Note: No checkpoint_complete here, since the checkpoint has been
+        // invalidated by the CLEAR op.
+        expect(lines2[1]).toEqual({
+            checkpoint_diff: expect.objectContaining({
+                last_op_id: '4'
+            })
+        });
+        expect(lines2[2]).toEqual({
+            data: expect.objectContaining({
+                has_more: false,
+                data: [
+                    expect.objectContaining({
+                        op: 'PUT'
+                    }),
+                    expect.objectContaining({
+                        op: 'PUT'
+                    })
+                ]
+            })
+        });
+        // Now we get a checkpoint_complete
+        expect(lines2[3]).toEqual({
+            checkpoint_complete: expect.objectContaining({
+                last_op_id: '4'
+            })
+        });
+    });
+    test('write checkpoint', async () => {
+        await using f = await factory();
+        const syncRules = await updateSyncRules(f, {
+            content: BASIC_SYNC_RULES
+        });
+        const bucketStorage = f.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        await writer.markAllSnapshotDone('0/1');
+        // <= the managed write checkpoint LSN below
+        await writer.commit('0/1');
+        const checkpoint = await bucketStorage.createManagedWriteCheckpoint({
+            user_id: 'test',
+            heads: { '1': '1/0' }
+        });
+        const params = {
+            syncContext,
+            bucketStorage,
+            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+            params: {
+                buckets: [],
+                include_checksum: true,
+                raw_data: true
+            },
+            tracker,
+            token: new JwtPayload({ sub: 'test', exp: Date.now() / 1000 + 10 }),
+            isEncodingAsBson: false
+        };
+        const stream1 = sync.streamResponse(params);
+        const lines1 = await consumeCheckpointLines(stream1);
+        // If write checkpoints are not correctly filtered, this may already
+        // contain the write checkpoint.
+        expect(lines1[0]).toMatchObject({
+            checkpoint: expect.objectContaining({
+                last_op_id: '0',
+                write_checkpoint: undefined
+            })
+        });
+        await writer.markAllSnapshotDone('0/1');
+        // must be >= the managed write checkpoint LSN
+        await writer.commit('1/0');
+        // At this point the LSN has advanced, so the write checkpoint should be
+        // included in the next checkpoint message.
+        const stream2 = sync.streamResponse(params);
+        const lines2 = await consumeCheckpointLines(stream2);
+        expect(lines2[0]).toMatchObject({
+            checkpoint: expect.objectContaining({
+                last_op_id: '0',
+                write_checkpoint: `${checkpoint}`
+            })
+        });
+    });
+    test('encodes sync rules id in buckets for streams', async () => {
+        await using f = await factory();
+        // This test relies making an actual update to sync rules to test the different bucket names.
+        // The actual naming scheme may change, as long as the two buckets have different names.
+        const rules = [
+            `
+streams:
+  test:
+    auto_subscribe: true
+    query: SELECT * FROM test;
+
+config:
+  edition: 2
+`,
+            `
+streams:
+  test2:
+    auto_subscribe: true
+    query: SELECT * FROM test WHERE 1;
+
+config:
+  edition: 2
+`
+        ];
+        for (let i = 0; i < 2; i++) {
             const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
+                content: rules[i]
             });
-            const bucketStorage = await f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_14, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            const bucketStorage = f.getInstance(syncRules);
+            await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config, i + 1);
             await writer.markAllSnapshotDone('0/1');
             await writer.save({
                 sourceTable: testTable,
@@ -1094,19 +1146,10 @@ bucket_definitions:
                 },
                 afterReplicaId: 't1'
             });
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't2',
-                    description: 'Test 2'
-                },
-                afterReplicaId: 't2'
-            });
             await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
-                bucketStorage,
+                bucketStorage: bucketStorage,
                 syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
                 params: {
                     buckets: [],
@@ -1117,241 +1160,8 @@ bucket_definitions:
                 token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
                 isEncodingAsBson: false
             });
-            const iter = stream[Symbol.asyncIterator]();
-            context.onTestFinished(() => {
-                iter.return?.();
-            });
-            // Only consume the first "checkpoint" message, and pause before receiving data.
-            const lines = await consumeIterator(iter, { consume: false, isDone: (line) => line?.checkpoint != null });
+            const lines = await consumeCheckpointLines(stream);
             expect(lines).toMatchSnapshot();
-            expect(lines[0]).toEqual({
-                checkpoint: expect.objectContaining({
-                    last_op_id: '2'
-                })
-            });
-            // Now we save additional data AND compact before continuing.
-            // This invalidates the checkpoint we've received above.
-            await writer.markAllSnapshotDone('0/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 't1',
-                    description: 'Test 1b'
-                },
-                afterReplicaId: 't1'
-            });
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 't2',
-                    description: 'Test 2b'
-                },
-                afterReplicaId: 't2'
-            });
-            await writer.commit('0/2');
-            await bucketStorage.compact({
-                minBucketChanges: 1,
-                minChangeRatio: 0
-            });
-            const lines2 = await getCheckpointLines(iter, { consume: true });
-            // Snapshot test checks for changes in general.
-            // The tests after that documents the specific things we're looking for
-            // in this test.
-            expect(lines2).toMatchSnapshot();
-            expect(lines2[0]).toEqual({
-                data: expect.objectContaining({
-                    has_more: false,
-                    data: [
-                        // The first two ops have been replaced by a single CLEAR op
-                        expect.objectContaining({
-                            op: 'CLEAR'
-                        })
-                    ]
-                })
-            });
-            // Note: No checkpoint_complete here, since the checkpoint has been
-            // invalidated by the CLEAR op.
-            expect(lines2[1]).toEqual({
-                checkpoint_diff: expect.objectContaining({
-                    last_op_id: '4'
-                })
-            });
-            expect(lines2[2]).toEqual({
-                data: expect.objectContaining({
-                    has_more: false,
-                    data: [
-                        expect.objectContaining({
-                            op: 'PUT'
-                        }),
-                        expect.objectContaining({
-                            op: 'PUT'
-                        })
-                    ]
-                })
-            });
-            // Now we get a checkpoint_complete
-            expect(lines2[3]).toEqual({
-                checkpoint_complete: expect.objectContaining({
-                    last_op_id: '4'
-                })
-            });
-        }
-        catch (e_14) {
-            env_14.error = e_14;
-            env_14.hasError = true;
-        }
-        finally {
-            const result_14 = __disposeResources(env_14);
-            if (result_14)
-                await result_14;
-        }
-    });
-    test('write checkpoint', async () => {
-        const env_15 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_15, await factory(), true);
-            const syncRules = await updateSyncRules(f, {
-                content: BASIC_SYNC_RULES
-            });
-            const bucketStorage = f.getInstance(syncRules);
-            const writer = __addDisposableResource(env_15, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            await writer.markAllSnapshotDone('0/1');
-            // <= the managed write checkpoint LSN below
-            await writer.commit('0/1');
-            const checkpoint = await bucketStorage.createManagedWriteCheckpoint({
-                user_id: 'test',
-                heads: { '1': '1/0' }
-            });
-            const params = {
-                syncContext,
-                bucketStorage,
-                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                params: {
-                    buckets: [],
-                    include_checksum: true,
-                    raw_data: true
-                },
-                tracker,
-                token: new JwtPayload({ sub: 'test', exp: Date.now() / 1000 + 10 }),
-                isEncodingAsBson: false
-            };
-            const stream1 = sync.streamResponse(params);
-            const lines1 = await consumeCheckpointLines(stream1);
-            // If write checkpoints are not correctly filtered, this may already
-            // contain the write checkpoint.
-            expect(lines1[0]).toMatchObject({
-                checkpoint: expect.objectContaining({
-                    last_op_id: '0',
-                    write_checkpoint: undefined
-                })
-            });
-            await writer.markAllSnapshotDone('0/1');
-            // must be >= the managed write checkpoint LSN
-            await writer.commit('1/0');
-            // At this point the LSN has advanced, so the write checkpoint should be
-            // included in the next checkpoint message.
-            const stream2 = sync.streamResponse(params);
-            const lines2 = await consumeCheckpointLines(stream2);
-            expect(lines2[0]).toMatchObject({
-                checkpoint: expect.objectContaining({
-                    last_op_id: '0',
-                    write_checkpoint: `${checkpoint}`
-                })
-            });
-        }
-        catch (e_15) {
-            env_15.error = e_15;
-            env_15.hasError = true;
-        }
-        finally {
-            const result_15 = __disposeResources(env_15);
-            if (result_15)
-                await result_15;
-        }
-    });
-    test('encodes sync rules id in buckets for streams', async () => {
-        const env_16 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_16, await factory(), true);
-            // This test relies making an actual update to sync rules to test the different bucket names.
-            // The actual naming scheme may change, as long as the two buckets have different names.
-            const rules = [
-                `
-streams:
-  test:
-    auto_subscribe: true
-    query: SELECT * FROM test;
-
-config:
-  edition: 2
-`,
-                `
-streams:
-  test2:
-    auto_subscribe: true
-    query: SELECT * FROM test WHERE 1;
-
-config:
-  edition: 2
-`
-            ];
-            for (let i = 0; i < 2; i++) {
-                const env_17 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const syncRules = await updateSyncRules(f, {
-                        content: rules[i]
-                    });
-                    const bucketStorage = f.getInstance(syncRules);
-                    const writer = __addDisposableResource(env_17, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-                    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config, i + 1);
-                    await writer.markAllSnapshotDone('0/1');
-                    await writer.save({
-                        sourceTable: testTable,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id: 't1',
-                            description: 'Test 1'
-                        },
-                        afterReplicaId: 't1'
-                    });
-                    await writer.commit('0/1');
-                    const stream = sync.streamResponse({
-                        syncContext,
-                        bucketStorage: bucketStorage,
-                        syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                        params: {
-                            buckets: [],
-                            include_checksum: true,
-                            raw_data: true
-                        },
-                        tracker,
-                        token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                        isEncodingAsBson: false
-                    });
-                    const lines = await consumeCheckpointLines(stream);
-                    expect(lines).toMatchSnapshot();
-                }
-                catch (e_16) {
-                    env_17.error = e_16;
-                    env_17.hasError = true;
-                }
-                finally {
-                    const result_16 = __disposeResources(env_17);
-                    if (result_16)
-                        await result_16;
-                }
-            }
-        }
-        catch (e_17) {
-            env_16.error = e_17;
-            env_16.hasError = true;
-        }
-        finally {
-            const result_17 = __disposeResources(env_16);
-            if (result_17)
-                await result_17;
         }
     });
 }