@powersync/service-core-tests 0.15.1 → 0.15.3

package/dist/tests/register-data-storage-data-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 { CURRENT_STORAGE_VERSION, getUuidReplicaIdentityBson, reduceBucket, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
 import { describe, expect, test } from 'vitest';
 import * as test_utils from '../test-utils/test-utils-index.js';
@@ -78,372 +26,223 @@ export function registerDataStorageDataTests(config) {
     const generateStorageFactory = config.factory;
     const storageVersion = config.storageVersion ?? storage.CURRENT_STORAGE_VERSION;
     test('removing row', async () => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_1, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, { storageVersion }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_1, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.DELETE,
-                beforeReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('1/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    checksum: d.checksum
-                };
-            });
-            const c1 = 2871785649;
-            const c2 = 2872534815;
-            expect(data).toEqual([
-                { op: 'PUT', object_id: 'test1', checksum: c1 },
-                { op: 'REMOVE', object_id: 'test1', checksum: c2 }
-            ]);
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
-            expect(checksums).toEqual([
-                {
-                    bucket: request.bucket,
-                    checksum: (c1 + c2) & 0xffffffff,
-                    count: 2
-                }
-            ]);
-        }
-        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;
-        }
+        const bucketStorage = factory.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('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('1/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                checksum: d.checksum
+            };
+        });
+        const c1 = 2871785649;
+        const c2 = 2872534815;
+        expect(data).toEqual([
+            { op: 'PUT', object_id: 'test1', checksum: c1 },
+            { op: 'REMOVE', object_id: 'test1', checksum: c2 }
+        ]);
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
+        expect(checksums).toEqual([
+            {
+                bucket: request.bucket,
+                checksum: (c1 + c2) & 0xffffffff,
+                count: 2
+            }
+        ]);
     });
     test('insert after delete in new batch', async () => {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_2, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, { storageVersion }));
-            const bucketStorage = factory.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('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.DELETE,
-                beforeReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('0/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('2/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    checksum: d.checksum
-                };
-            });
-            const c1 = 2871785649;
-            expect(data).toEqual([{ op: 'PUT', object_id: 'test1', checksum: c1 }]);
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
-            expect(checksums).toEqual([
-                {
-                    bucket: request.bucket,
-                    checksum: c1 & 0xffffffff,
-                    count: 1
-                }
-            ]);
-        }
-        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 = factory.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('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('2/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                checksum: d.checksum
+            };
+        });
+        const c1 = 2871785649;
+        expect(data).toEqual([{ op: 'PUT', object_id: 'test1', checksum: c1 }]);
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
+        expect(checksums).toEqual([
+            {
+                bucket: request.bucket,
+                checksum: c1 & 0xffffffff,
+                count: 1
+            }
+        ]);
     });
     test('update after delete in new batch', async () => {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            // Update after delete may not be common, but the storage layer should handle it in an eventually-consistent way.
-            const factory = __addDisposableResource(env_3, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        // Update after delete may not be common, but the storage layer should handle it in an eventually-consistent way.
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, { storageVersion }));
-            const bucketStorage = factory.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('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.DELETE,
-                beforeReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('0/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                before: {
-                    id: 'test1'
-                },
-                after: {
-                    id: 'test1',
-                    description: 'test1'
-                },
-                beforeReplicaId: test_utils.rid('test1'),
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('2/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    checksum: d.checksum
-                };
-            });
-            const c1 = 2871785649;
-            expect(data).toEqual([{ op: 'PUT', object_id: 'test1', checksum: c1 }]);
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
-            expect(checksums).toEqual([
-                {
-                    bucket: request.bucket,
-                    checksum: c1 & 0xffffffff,
-                    count: 1
-                }
-            ]);
-        }
-        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;
-        }
+        const bucketStorage = factory.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('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('0/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: {
+                id: 'test1'
+            },
+            after: {
+                id: 'test1',
+                description: 'test1'
+            },
+            beforeReplicaId: test_utils.rid('test1'),
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('2/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                checksum: d.checksum
+            };
+        });
+        const c1 = 2871785649;
+        expect(data).toEqual([{ op: 'PUT', object_id: 'test1', checksum: c1 }]);
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
+        expect(checksums).toEqual([
+            {
+                bucket: request.bucket,
+                checksum: c1 & 0xffffffff,
+                count: 1
+            }
+        ]);
     });
     test('insert after delete in same batch', async () => {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_4, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.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('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.DELETE,
-                beforeReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('1/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    checksum: d.checksum
-                };
-            });
-            const c1 = 2871785649;
-            expect(data).toEqual([{ op: 'PUT', object_id: 'test1', checksum: c1 }]);
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
-            expect(checksums).toEqual([
-                {
-                    bucket: request.bucket,
-                    checksum: c1 & 0xffffffff,
-                    count: 1
-                }
-            ]);
-        }
-        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;
-        }
-    });
-    test('(insert, delete, insert), (delete)', async () => {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_5, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
-bucket_definitions:
-  global:
-    data:
-      - SELECT id, description FROM "%"
-`, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            {
-                const env_6 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const writer = __addDisposableResource(env_6, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-                    const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-                    await writer.markAllSnapshotDone('1/1');
-                    await writer.save({
-                        sourceTable,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id: 'test1',
-                            description: 'test1'
-                        },
-                        afterReplicaId: test_utils.rid('test1')
-                    });
-                    await writer.save({
-                        sourceTable,
-                        tag: storage.SaveOperationTag.DELETE,
-                        beforeReplicaId: test_utils.rid('test1')
-                    });
-                    await writer.save({
-                        sourceTable,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id: 'test1',
-                            description: 'test1'
-                        },
-                        afterReplicaId: test_utils.rid('test1')
-                    });
-                    await writer.commit('1/1');
-                }
-                catch (e_5) {
-                    env_6.error = e_5;
-                    env_6.hasError = true;
-                }
-                finally {
-                    const result_5 = __disposeResources(env_6);
-                    if (result_5)
-                        await result_5;
-                }
-            }
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('1/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                checksum: d.checksum
+            };
+        });
+        const c1 = 2871785649;
+        expect(data).toEqual([{ op: 'PUT', object_id: 'test1', checksum: c1 }]);
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
+        expect(checksums).toEqual([
             {
-                const env_7 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const writer = __addDisposableResource(env_7, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-                    const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-                    await writer.markAllSnapshotDone('1/1');
-                    await writer.save({
-                        sourceTable,
-                        tag: storage.SaveOperationTag.DELETE,
-                        beforeReplicaId: test_utils.rid('test1')
-                    });
-                    await writer.commit('2/1');
-                }
-                catch (e_6) {
-                    env_7.error = e_6;
-                    env_7.hasError = true;
-                }
-                finally {
-                    const result_6 = __disposeResources(env_7);
-                    if (result_6)
-                        await result_6;
-                }
+                bucket: request.bucket,
+                checksum: c1 & 0xffffffff,
+                count: 1
             }
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
-            expect(reduceBucket(batch[0].chunkData.data).slice(1)).toEqual([]);
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    checksum: d.checksum
-                };
-            });
-            expect(data).toMatchSnapshot();
-        }
-        catch (e_7) {
-            env_5.error = e_7;
-            env_5.hasError = true;
-        }
-        finally {
-            const result_7 = __disposeResources(env_5);
-            if (result_7)
-                await result_7;
-        }
+        ]);
     });
-    test('changing client ids', async () => {
-        const env_8 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_8, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+    test('(insert, delete, insert), (delete)', async () => {
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
-      - SELECT client_id as id, description FROM "%"
+      - SELECT id, description FROM "%"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_8, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
             await writer.save({
@@ -451,73 +250,15 @@ bucket_definitions:
                 tag: storage.SaveOperationTag.INSERT,
                 after: {
                     id: 'test1',
-                    client_id: 'client1a',
-                    description: 'test1a'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 'test1',
-                    client_id: 'client1b',
-                    description: 'test1b'
+                    description: 'test1'
                 },
                 afterReplicaId: test_utils.rid('test1')
             });
             await writer.save({
                 sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test2',
-                    client_id: 'client2',
-                    description: 'test2'
-                },
-                afterReplicaId: test_utils.rid('test2')
-            });
-            await writer.commit('1/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [bucketRequest(syncRules, 'global[]')]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id
-                };
+                tag: storage.SaveOperationTag.DELETE,
+                beforeReplicaId: test_utils.rid('test1')
             });
-            expect(data).toEqual([
-                { op: 'PUT', object_id: 'client1a' },
-                { op: 'PUT', object_id: 'client1b' },
-                { op: 'REMOVE', object_id: 'client1a' },
-                { op: 'PUT', object_id: 'client2' }
-            ]);
-        }
-        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;
-        }
-    });
-    test('re-apply delete', async () => {
-        const env_9 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_9, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
-bucket_definitions:
-  global:
-    data:
-      - SELECT id, description FROM "%"
-`, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_9, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
             await writer.save({
                 sourceTable,
                 tag: storage.SaveOperationTag.INSERT,
@@ -527,738 +268,753 @@ bucket_definitions:
                 },
                 afterReplicaId: test_utils.rid('test1')
             });
-            await writer.flush();
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.DELETE,
-                beforeReplicaId: test_utils.rid('test1')
-            });
             await writer.commit('1/1');
+        }
+        {
+            await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
             await writer.save({
                 sourceTable,
                 tag: storage.SaveOperationTag.DELETE,
                 beforeReplicaId: test_utils.rid('test1')
             });
-            await writer.flush();
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    checksum: d.checksum
-                };
-            });
-            const c1 = 2871785649;
-            const c2 = 2872534815;
-            expect(data).toEqual([
-                { op: 'PUT', object_id: 'test1', checksum: c1 },
-                { op: 'REMOVE', object_id: 'test1', checksum: c2 }
-            ]);
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
-            expect(checksums).toEqual([
-                {
-                    bucket: bucketRequest(syncRules, 'global[]').bucket,
-                    checksum: (c1 + c2) & 0xffffffff,
-                    count: 2
-                }
-            ]);
-        }
-        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 writer.commit('2/1');
         }
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
+        expect(reduceBucket(batch[0].chunkData.data).slice(1)).toEqual([]);
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                checksum: d.checksum
+            };
+        });
+        expect(data).toMatchSnapshot();
+    });
+    test('changing client ids', async () => {
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT client_id as id, description FROM "%"
+`, {
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                client_id: 'client1a',
+                description: 'test1a'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 'test1',
+                client_id: 'client1b',
+                description: 'test1b'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test2',
+                client_id: 'client2',
+                description: 'test2'
+            },
+            afterReplicaId: test_utils.rid('test2')
+        });
+        await writer.commit('1/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [bucketRequest(syncRules, 'global[]')]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id
+            };
+        });
+        expect(data).toEqual([
+            { op: 'PUT', object_id: 'client1a' },
+            { op: 'PUT', object_id: 'client1b' },
+            { op: 'REMOVE', object_id: 'client1a' },
+            { op: 'PUT', object_id: 'client2' }
+        ]);
+    });
+    test('re-apply delete', async () => {
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "%"
+`, {
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.flush();
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.flush();
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                checksum: d.checksum
+            };
+        });
+        const c1 = 2871785649;
+        const c2 = 2872534815;
+        expect(data).toEqual([
+            { op: 'PUT', object_id: 'test1', checksum: c1 },
+            { op: 'REMOVE', object_id: 'test1', checksum: c2 }
+        ]);
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
+        expect(checksums).toEqual([
+            {
+                bucket: bucketRequest(syncRules, 'global[]').bucket,
+                checksum: (c1 + c2) & 0xffffffff,
+                count: 2
+            }
+        ]);
     });
     test('re-apply update + delete', async () => {
-        const env_10 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_10, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, { storageVersion }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_10, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.flush();
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 'test1',
-                    description: undefined
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 'test1',
-                    description: undefined
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.DELETE,
-                beforeReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('1/1');
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 'test1',
-                    description: undefined
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 'test1',
-                    description: undefined
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.DELETE,
-                beforeReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('2/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    checksum: d.checksum
-                };
-            });
-            const c1 = 2871785649;
-            const c2 = 2872534815;
-            expect(data).toEqual([
-                { op: 'PUT', object_id: 'test1', checksum: c1 },
-                { op: 'PUT', object_id: 'test1', checksum: c1 },
-                { op: 'PUT', object_id: 'test1', checksum: c1 },
-                { op: 'REMOVE', object_id: 'test1', checksum: c2 }
-            ]);
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
-            expect(checksums).toEqual([
-                {
-                    bucket: bucketRequest(syncRules, 'global[]').bucket,
-                    checksum: (c1 + c1 + c1 + c2) & 0xffffffff,
-                    count: 4
-                }
-            ]);
-        }
-        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 = factory.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('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.flush();
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 'test1',
+                description: undefined
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 'test1',
+                description: undefined
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('1/1');
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 'test1',
+                description: undefined
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 'test1',
+                description: undefined
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.DELETE,
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('2/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                checksum: d.checksum
+            };
+        });
+        const c1 = 2871785649;
+        const c2 = 2872534815;
+        expect(data).toEqual([
+            { op: 'PUT', object_id: 'test1', checksum: c1 },
+            { op: 'PUT', object_id: 'test1', checksum: c1 },
+            { op: 'PUT', object_id: 'test1', checksum: c1 },
+            { op: 'REMOVE', object_id: 'test1', checksum: c2 }
+        ]);
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
+        expect(checksums).toEqual([
+            {
+                bucket: bucketRequest(syncRules, 'global[]').bucket,
+                checksum: (c1 + c1 + c1 + c2) & 0xffffffff,
+                count: 4
+            }
+        ]);
     });
     test('batch with overlapping replica ids', async () => {
-        const env_11 = { stack: [], error: void 0, hasError: false };
-        try {
-            // This test checks that we get the correct output when processing rows with:
-            // 1. changing replica ids
-            // 2. overlapping with replica ids of other rows in the same transaction (at different times)
-            // If operations are not processing in input order, this breaks easily.
-            // It can break at two places:
-            // 1. Not getting the correct "current_data" state for each operation.
-            // 2. Output order not being correct.
-            const factory = __addDisposableResource(env_11, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        // This test checks that we get the correct output when processing rows with:
+        // 1. changing replica ids
+        // 2. overlapping with replica ids of other rows in the same transaction (at different times)
+        // If operations are not processing in input order, this breaks easily.
+        // It can break at two places:
+        // 1. Not getting the correct "current_data" state for each operation.
+        // 2. Output order not being correct.
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "test"
 `, { storageVersion }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_11, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            // Pre-setup
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test2',
-                    description: 'test2a'
-                },
-                afterReplicaId: test_utils.rid('test2')
-            });
-            const result1 = await writer.flush();
-            const checkpoint1 = result1?.flushed_op ?? 0n;
-            // Test batch
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        // Pre-setup
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test2',
+                description: 'test2a'
+            },
+            afterReplicaId: test_utils.rid('test2')
+        });
+        const result1 = await writer.flush();
+        const checkpoint1 = result1?.flushed_op ?? 0n;
+        // Test batch
+        // b
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1b'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: {
+                id: 'test1'
+            },
+            beforeReplicaId: test_utils.rid('test1'),
+            after: {
+                id: 'test2',
+                description: 'test2b'
+            },
+            afterReplicaId: test_utils.rid('test2')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: {
+                id: 'test2'
+            },
+            beforeReplicaId: test_utils.rid('test2'),
+            after: {
+                id: 'test3',
+                description: 'test3b'
+            },
+            afterReplicaId: test_utils.rid('test3')
+        });
+        // c
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 'test2',
+                description: 'test2c'
+            },
+            afterReplicaId: test_utils.rid('test2')
+        });
+        // d
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test4',
+                description: 'test4d'
+            },
+            afterReplicaId: test_utils.rid('test4')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: {
+                id: 'test4'
+            },
+            beforeReplicaId: test_utils.rid('test4'),
+            after: {
+                id: 'test5',
+                description: 'test5d'
+            },
+            afterReplicaId: test_utils.rid('test5')
+        });
+        const result2 = await writer.flush();
+        const checkpoint2 = result2.flushed_op;
+        const request = bucketRequest(syncRules, 'global[]', checkpoint1);
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint2, [request]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                data: normalizeOplogData(d.data)
+            };
+        });
+        // Operations must be in this order
+        expect(data).toEqual([
             // b
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1b'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                before: {
-                    id: 'test1'
-                },
-                beforeReplicaId: test_utils.rid('test1'),
-                after: {
-                    id: 'test2',
-                    description: 'test2b'
-                },
-                afterReplicaId: test_utils.rid('test2')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                before: {
-                    id: 'test2'
-                },
-                beforeReplicaId: test_utils.rid('test2'),
-                after: {
-                    id: 'test3',
-                    description: 'test3b'
-                },
-                afterReplicaId: test_utils.rid('test3')
-            });
+            { op: 'PUT', object_id: 'test1', data: JSON.stringify({ id: 'test1', description: 'test1b' }) },
+            { op: 'REMOVE', object_id: 'test1', data: null },
+            { op: 'PUT', object_id: 'test2', data: JSON.stringify({ id: 'test2', description: 'test2b' }) },
+            { op: 'REMOVE', object_id: 'test2', data: null },
+            { op: 'PUT', object_id: 'test3', data: JSON.stringify({ id: 'test3', description: 'test3b' }) },
             // c
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 'test2',
-                    description: 'test2c'
-                },
-                afterReplicaId: test_utils.rid('test2')
-            });
+            { op: 'PUT', object_id: 'test2', data: JSON.stringify({ id: 'test2', description: 'test2c' }) },
             // d
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test4',
-                    description: 'test4d'
-                },
-                afterReplicaId: test_utils.rid('test4')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                before: {
-                    id: 'test4'
-                },
-                beforeReplicaId: test_utils.rid('test4'),
-                after: {
-                    id: 'test5',
-                    description: 'test5d'
-                },
-                afterReplicaId: test_utils.rid('test5')
-            });
-            const result2 = await writer.flush();
-            const checkpoint2 = result2.flushed_op;
-            const request = bucketRequest(syncRules, 'global[]', checkpoint1);
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint2, [request]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    data: normalizeOplogData(d.data)
-                };
-            });
-            // Operations must be in this order
-            expect(data).toEqual([
-                // b
-                { op: 'PUT', object_id: 'test1', data: JSON.stringify({ id: 'test1', description: 'test1b' }) },
-                { op: 'REMOVE', object_id: 'test1', data: null },
-                { op: 'PUT', object_id: 'test2', data: JSON.stringify({ id: 'test2', description: 'test2b' }) },
-                { op: 'REMOVE', object_id: 'test2', data: null },
-                { op: 'PUT', object_id: 'test3', data: JSON.stringify({ id: 'test3', description: 'test3b' }) },
-                // c
-                { op: 'PUT', object_id: 'test2', data: JSON.stringify({ id: 'test2', description: 'test2c' }) },
-                // d
-                { op: 'PUT', object_id: 'test4', data: JSON.stringify({ id: 'test4', description: 'test4d' }) },
-                { op: 'REMOVE', object_id: 'test4', data: null },
-                { op: 'PUT', object_id: 'test5', data: JSON.stringify({ id: 'test5', description: 'test5d' }) }
-            ]);
-        }
-        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;
-        }
+            { op: 'PUT', object_id: 'test4', data: JSON.stringify({ id: 'test4', description: 'test4d' }) },
+            { op: 'REMOVE', object_id: 'test4', data: null },
+            { op: 'PUT', object_id: 'test5', data: JSON.stringify({ id: 'test5', description: 'test5d' }) }
+        ]);
     });
     test('changed data with replica identity full', async () => {
-        const env_12 = { stack: [], error: void 0, hasError: false };
-        try {
-            function rid2(id, description) {
-                return getUuidReplicaIdentityBson({ id, description }, [
-                    { name: 'id', type: 'VARCHAR', typeId: 25 },
-                    { name: 'description', type: 'VARCHAR', typeId: 25 }
-                ]);
-            }
-            const factory = __addDisposableResource(env_12, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
-bucket_definitions:
-  global:
-    data:
-      - SELECT id, description FROM "test"
-`, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_12, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = test_utils.makeTestTable('test', ['id', 'description'], config);
-            // Pre-setup
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                afterReplicaId: rid2('test1', 'test1a')
-            });
-            const result1 = await writer.flush();
-            const checkpoint1 = result1?.flushed_op ?? 0n;
-            // Unchanged, but has a before id
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                before: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                beforeReplicaId: rid2('test1', 'test1a'),
-                after: {
-                    id: 'test1',
-                    description: 'test1b'
-                },
-                afterReplicaId: rid2('test1', 'test1b')
-            });
-            const result2 = await writer.flush();
-            // Delete
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.DELETE,
-                before: {
-                    id: 'test1',
-                    description: 'test1b'
-                },
-                beforeReplicaId: rid2('test1', 'test1b'),
-                after: undefined
-            });
-            const result3 = await writer.flush();
-            const checkpoint3 = result3.flushed_op;
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint3, [{ ...request, start: checkpoint1 }]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    data: normalizeOplogData(d.data),
-                    subkey: d.subkey
-                };
-            });
-            // Operations must be in this order
-            expect(data).toEqual([
-                // 2
-                // The REMOVE is expected because the subkey changes
-                {
-                    op: 'REMOVE',
-                    object_id: 'test1',
-                    data: null,
-                    subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
-                },
-                {
-                    op: 'PUT',
-                    object_id: 'test1',
-                    data: JSON.stringify({ id: 'test1', description: 'test1b' }),
-                    subkey: '6544e3899293153fa7b38331/500e9b68-a2fd-51ff-9c00-313e2fb9f562'
-                },
-                // 3
-                {
-                    op: 'REMOVE',
-                    object_id: 'test1',
-                    data: null,
-                    subkey: '6544e3899293153fa7b38331/500e9b68-a2fd-51ff-9c00-313e2fb9f562'
-                }
-            ]);
-        }
-        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;
+        function rid2(id, description) {
+            return getUuidReplicaIdentityBson({ id, description }, [
+                { name: 'id', type: 'VARCHAR', typeId: 25 },
+                { name: 'description', type: 'VARCHAR', typeId: 25 }
+            ]);
         }
-    });
-    test('unchanged data with replica identity full', async () => {
-        const env_13 = { stack: [], error: void 0, hasError: false };
-        try {
-            function rid2(id, description) {
-                return getUuidReplicaIdentityBson({ id, description }, [
-                    { name: 'id', type: 'VARCHAR', typeId: 25 },
-                    { name: 'description', type: 'VARCHAR', typeId: 25 }
-                ]);
-            }
-            const factory = __addDisposableResource(env_13, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "test"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_13, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = test_utils.makeTestTable('test', ['id', 'description'], config);
-            // Pre-setup
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                afterReplicaId: rid2('test1', 'test1a')
-            });
-            const result1 = await writer.flush();
-            const checkpoint1 = result1?.flushed_op ?? 0n;
-            // Unchanged, but has a before id
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.UPDATE,
-                before: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                beforeReplicaId: rid2('test1', 'test1a'),
-                after: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                afterReplicaId: rid2('test1', 'test1a')
-            });
-            const result2 = await writer.flush();
-            // Delete
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.DELETE,
-                before: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                beforeReplicaId: rid2('test1', 'test1a'),
-                after: undefined
-            });
-            const result3 = await writer.flush();
-            const checkpoint3 = result3.flushed_op;
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint3, [{ ...request, start: checkpoint1 }]));
-            const data = batch[0].chunkData.data.map((d) => {
-                return {
-                    op: d.op,
-                    object_id: d.object_id,
-                    data: normalizeOplogData(d.data),
-                    subkey: d.subkey
-                };
-            });
-            // Operations must be in this order
-            expect(data).toEqual([
-                // 2
-                {
-                    op: 'PUT',
-                    object_id: 'test1',
-                    data: JSON.stringify({ id: 'test1', description: 'test1a' }),
-                    subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
-                },
-                // 3
-                {
-                    op: 'REMOVE',
-                    object_id: 'test1',
-                    data: null,
-                    subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
-                }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const sourceTable = test_utils.makeTestTable('test', ['id', 'description'], config);
+        // Pre-setup
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            afterReplicaId: rid2('test1', 'test1a')
+        });
+        const result1 = await writer.flush();
+        const checkpoint1 = result1?.flushed_op ?? 0n;
+        // Unchanged, but has a before id
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            beforeReplicaId: rid2('test1', 'test1a'),
+            after: {
+                id: 'test1',
+                description: 'test1b'
+            },
+            afterReplicaId: rid2('test1', 'test1b')
+        });
+        const result2 = await writer.flush();
+        // Delete
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.DELETE,
+            before: {
+                id: 'test1',
+                description: 'test1b'
+            },
+            beforeReplicaId: rid2('test1', 'test1b'),
+            after: undefined
+        });
+        const result3 = await writer.flush();
+        const checkpoint3 = result3.flushed_op;
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint3, [{ ...request, start: checkpoint1 }]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                data: normalizeOplogData(d.data),
+                subkey: d.subkey
+            };
+        });
+        // Operations must be in this order
+        expect(data).toEqual([
+            // 2
+            // The REMOVE is expected because the subkey changes
+            {
+                op: 'REMOVE',
+                object_id: 'test1',
+                data: null,
+                subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
+            },
+            {
+                op: 'PUT',
+                object_id: 'test1',
+                data: JSON.stringify({ id: 'test1', description: 'test1b' }),
+                subkey: '6544e3899293153fa7b38331/500e9b68-a2fd-51ff-9c00-313e2fb9f562'
+            },
+            // 3
+            {
+                op: 'REMOVE',
+                object_id: 'test1',
+                data: null,
+                subkey: '6544e3899293153fa7b38331/500e9b68-a2fd-51ff-9c00-313e2fb9f562'
+            }
+        ]);
+    });
+    test('unchanged data with replica identity full', async () => {
+        function rid2(id, description) {
+            return getUuidReplicaIdentityBson({ id, description }, [
+                { name: 'id', type: 'VARCHAR', typeId: 25 },
+                { name: 'description', type: 'VARCHAR', typeId: 25 }
             ]);
         }
-        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 factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test"
+`, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const sourceTable = test_utils.makeTestTable('test', ['id', 'description'], config);
+        // Pre-setup
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            afterReplicaId: rid2('test1', 'test1a')
+        });
+        const result1 = await writer.flush();
+        const checkpoint1 = result1?.flushed_op ?? 0n;
+        // Unchanged, but has a before id
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            beforeReplicaId: rid2('test1', 'test1a'),
+            after: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            afterReplicaId: rid2('test1', 'test1a')
+        });
+        const result2 = await writer.flush();
+        // Delete
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.DELETE,
+            before: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            beforeReplicaId: rid2('test1', 'test1a'),
+            after: undefined
+        });
+        const result3 = await writer.flush();
+        const checkpoint3 = result3.flushed_op;
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint3, [{ ...request, start: checkpoint1 }]));
+        const data = batch[0].chunkData.data.map((d) => {
+            return {
+                op: d.op,
+                object_id: d.object_id,
+                data: normalizeOplogData(d.data),
+                subkey: d.subkey
+            };
+        });
+        // Operations must be in this order
+        expect(data).toEqual([
+            // 2
+            {
+                op: 'PUT',
+                object_id: 'test1',
+                data: JSON.stringify({ id: 'test1', description: 'test1a' }),
+                subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
+            },
+            // 3
+            {
+                op: 'REMOVE',
+                object_id: 'test1',
+                data: null,
+                subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
+            }
+        ]);
     });
     test('large batch', async () => {
-        const env_14 = { stack: [], error: void 0, hasError: false };
-        try {
-            // Test syncing a batch of data that is small in count,
-            // but large enough in size to be split over multiple returned batches.
-            // The specific batch splits is an implementation detail of the storage driver,
-            // and the test will have to updated when other implementations are added.
-            const factory = __addDisposableResource(env_14, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        // Test syncing a batch of data that is small in count,
+        // but large enough in size to be split over multiple returned batches.
+        // The specific batch splits is an implementation detail of the storage driver,
+        // and the test will have to updated when other implementations are added.
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_14, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            const largeDescription = '0123456789'.repeat(12_000_00);
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'large1',
-                    description: largeDescription
-                },
-                afterReplicaId: test_utils.rid('large1')
-            });
-            // Large enough to split the returned batch
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'large2',
-                    description: largeDescription
-                },
-                afterReplicaId: test_utils.rid('large2')
-            });
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test3',
-                    description: 'test3'
-                },
-                afterReplicaId: test_utils.rid('test3')
-            });
-            await writer.commit('1/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const options = {
-                chunkLimitBytes: 16 * 1024 * 1024
-            };
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch1 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request], options));
-            expect(test_utils.getBatchData(batch1)).toEqual([
-                { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
-                { op_id: '2', op: 'PUT', object_id: 'large1', checksum: 454746904 }
-            ]);
-            expect(test_utils.getBatchMeta(batch1)).toEqual({
-                after: '0',
-                has_more: true,
-                next_after: '2'
-            });
-            const batch2 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch1[0].chunkData.next_after) }], options));
-            expect(test_utils.getBatchData(batch2)).toEqual([
-                { op_id: '3', op: 'PUT', object_id: 'large2', checksum: 1795508474 },
-                { op_id: '4', op: 'PUT', object_id: 'test3', checksum: 1359888332 }
-            ]);
-            expect(test_utils.getBatchMeta(batch2)).toEqual({
-                after: '2',
-                has_more: false,
-                next_after: '4'
-            });
-            const batch3 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch2[0].chunkData.next_after) }], options));
-            expect(test_utils.getBatchData(batch3)).toEqual([]);
-            expect(test_utils.getBatchMeta(batch3)).toEqual(null);
-        }
-        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;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
+        const largeDescription = '0123456789'.repeat(12_000_00);
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'large1',
+                description: largeDescription
+            },
+            afterReplicaId: test_utils.rid('large1')
+        });
+        // Large enough to split the returned batch
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'large2',
+                description: largeDescription
+            },
+            afterReplicaId: test_utils.rid('large2')
+        });
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test3',
+                description: 'test3'
+            },
+            afterReplicaId: test_utils.rid('test3')
+        });
+        await writer.commit('1/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const options = {
+            chunkLimitBytes: 16 * 1024 * 1024
+        };
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch1 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request], options));
+        expect(test_utils.getBatchData(batch1)).toEqual([
+            { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
+            { op_id: '2', op: 'PUT', object_id: 'large1', checksum: 454746904 }
+        ]);
+        expect(test_utils.getBatchMeta(batch1)).toEqual({
+            after: '0',
+            has_more: true,
+            next_after: '2'
+        });
+        const batch2 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch1[0].chunkData.next_after) }], options));
+        expect(test_utils.getBatchData(batch2)).toEqual([
+            { op_id: '3', op: 'PUT', object_id: 'large2', checksum: 1795508474 },
+            { op_id: '4', op: 'PUT', object_id: 'test3', checksum: 1359888332 }
+        ]);
+        expect(test_utils.getBatchMeta(batch2)).toEqual({
+            after: '2',
+            has_more: false,
+            next_after: '4'
+        });
+        const batch3 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch2[0].chunkData.next_after) }], options));
+        expect(test_utils.getBatchData(batch3)).toEqual([]);
+        expect(test_utils.getBatchMeta(batch3)).toEqual(null);
     });
     test('long batch', async () => {
-        const env_15 = { stack: [], error: void 0, hasError: false };
-        try {
-            // Test syncing a batch of data that is limited by count.
-            const factory = __addDisposableResource(env_15, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        // Test syncing a batch of data that is limited by count.
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, {
-                storageVersion
-            }));
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
+        for (let i = 1; i <= 6; i++) {
+            await writer.save({
+                sourceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: `test${i}`,
+                    description: `test${i}`
+                },
+                afterReplicaId: `test${i}`
+            });
+        }
+        await writer.commit('1/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const batch1 = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request], { limit: 4 }));
+        expect(test_utils.getBatchData(batch1)).toEqual([
+            { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
+            { op_id: '2', op: 'PUT', object_id: 'test2', checksum: 730027011 },
+            { op_id: '3', op: 'PUT', object_id: 'test3', checksum: 1359888332 },
+            { op_id: '4', op: 'PUT', object_id: 'test4', checksum: 2049153252 }
+        ]);
+        expect(test_utils.getBatchMeta(batch1)).toEqual({
+            after: '0',
+            has_more: true,
+            next_after: '4'
+        });
+        const batch2 = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch1.chunkData.next_after) }], {
+            limit: 4
+        }));
+        expect(test_utils.getBatchData(batch2)).toEqual([
+            { op_id: '5', op: 'PUT', object_id: 'test5', checksum: 3686902721 },
+            { op_id: '6', op: 'PUT', object_id: 'test6', checksum: 1974820016 }
+        ]);
+        expect(test_utils.getBatchMeta(batch2)).toEqual({
+            after: '4',
+            has_more: false,
+            next_after: '6'
+        });
+        const batch3 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch2.chunkData.next_after) }], {
+            limit: 4
+        }));
+        expect(test_utils.getBatchData(batch3)).toEqual([]);
+        expect(test_utils.getBatchMeta(batch3)).toEqual(null);
+    });
+    describe('batch has_more', () => {
+        const setup = async (options) => {
+            await using factory = await generateStorageFactory();
+            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+  bucket_definitions:
+    global1:
+      data:
+        - SELECT id, description FROM test WHERE bucket = 'global1'
+    global2:
+      data:
+        - SELECT id, description FROM test WHERE bucket = 'global2'
+  `, { storageVersion }));
             const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_15, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
             const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
             await writer.markAllSnapshotDone('1/1');
-            for (let i = 1; i <= 6; i++) {
+            for (let i = 1; i <= 10; i++) {
                 await writer.save({
                     sourceTable,
                     tag: storage.SaveOperationTag.INSERT,
                     after: {
                         id: `test${i}`,
-                        description: `test${i}`
+                        description: `test${i}`,
+                        bucket: i == 1 ? 'global1' : 'global2'
                     },
                     afterReplicaId: `test${i}`
                 });
             }
             await writer.commit('1/1');
             const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const batch1 = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request], { limit: 4 }));
-            expect(test_utils.getBatchData(batch1)).toEqual([
-                { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
-                { op_id: '2', op: 'PUT', object_id: 'test2', checksum: 730027011 },
-                { op_id: '3', op: 'PUT', object_id: 'test3', checksum: 1359888332 },
-                { op_id: '4', op: 'PUT', object_id: 'test4', checksum: 2049153252 }
-            ]);
-            expect(test_utils.getBatchMeta(batch1)).toEqual({
-                after: '0',
-                has_more: true,
-                next_after: '4'
-            });
-            const batch2 = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch1.chunkData.next_after) }], {
-                limit: 4
-            }));
-            expect(test_utils.getBatchData(batch2)).toEqual([
-                { op_id: '5', op: 'PUT', object_id: 'test5', checksum: 3686902721 },
-                { op_id: '6', op: 'PUT', object_id: 'test6', checksum: 1974820016 }
-            ]);
-            expect(test_utils.getBatchMeta(batch2)).toEqual({
-                after: '4',
-                has_more: false,
-                next_after: '6'
-            });
-            const batch3 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [{ ...request, start: BigInt(batch2.chunkData.next_after) }], {
-                limit: 4
-            }));
-            expect(test_utils.getBatchData(batch3)).toEqual([]);
-            expect(test_utils.getBatchMeta(batch3)).toEqual(null);
-        }
-        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;
-        }
-    });
-    describe('batch has_more', () => {
-        const setup = async (options) => {
-            const env_16 = { stack: [], error: void 0, hasError: false };
-            try {
-                const factory = __addDisposableResource(env_16, await generateStorageFactory(), true);
-                const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
-  bucket_definitions:
-    global1:
-      data:
-        - SELECT id, description FROM test WHERE bucket = 'global1'
-    global2:
-      data:
-        - SELECT id, description FROM test WHERE bucket = 'global2'
-  `, { storageVersion }));
-                const bucketStorage = factory.getInstance(syncRules);
-                const writer = __addDisposableResource(env_16, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-                const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-                await writer.markAllSnapshotDone('1/1');
-                for (let i = 1; i <= 10; i++) {
-                    await writer.save({
-                        sourceTable,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id: `test${i}`,
-                            description: `test${i}`,
-                            bucket: i == 1 ? 'global1' : 'global2'
-                        },
-                        afterReplicaId: `test${i}`
-                    });
-                }
-                await writer.commit('1/1');
-                const { checkpoint } = await bucketStorage.getCheckpoint();
-                const global1Request = bucketRequest(syncRules, 'global1[]', 0n);
-                const global2Request = bucketRequest(syncRules, 'global2[]', 0n);
-                const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [global1Request, global2Request], options));
-                return { batch, global1Request, global2Request };
-            }
-            catch (e_16) {
-                env_16.error = e_16;
-                env_16.hasError = true;
-            }
-            finally {
-                const result_16 = __disposeResources(env_16);
-                if (result_16)
-                    await result_16;
-            }
+            const global1Request = bucketRequest(syncRules, 'global1[]', 0n);
+            const global2Request = bucketRequest(syncRules, 'global2[]', 0n);
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, [global1Request, global2Request], options));
+            return { batch, global1Request, global2Request };
         };
         test('batch has_more (1)', async () => {
             const { batch, global1Request, global2Request } = await setup({ limit: 5 });
@@ -1349,330 +1105,247 @@ bucket_definitions:
         });
     });
     test('empty storage metrics', async () => {
-        const env_17 = { stack: [], error: void 0, hasError: false };
-        try {
-            const f = __addDisposableResource(env_17, await generateStorageFactory({ dropAll: true }), true);
-            const metrics = await f.getStorageMetrics();
-            expect(metrics).toEqual({
-                operations_size_bytes: 0,
-                parameters_size_bytes: 0,
-                replication_size_bytes: 0
-            });
-            const r = await f.configureSyncRules(updateSyncRulesFromYaml('bucket_definitions: {}'));
-            const storage = f.getInstance(r.persisted_sync_rules);
-            const writer = __addDisposableResource(env_17, await storage.createWriter(test_utils.BATCH_OPTIONS), true);
-            await writer.markAllSnapshotDone('1/0');
-            await writer.keepalive('1/0');
-            await f.getStorageMetrics();
-        }
-        catch (e_17) {
-            env_17.error = e_17;
-            env_17.hasError = true;
-        }
-        finally {
-            const result_17 = __disposeResources(env_17);
-            if (result_17)
-                await result_17;
-        }
+        await using f = await generateStorageFactory({ dropAll: true });
+        const metrics = await f.getStorageMetrics();
+        expect(metrics).toEqual({
+            operations_size_bytes: 0,
+            parameters_size_bytes: 0,
+            replication_size_bytes: 0
+        });
+        const r = await f.configureSyncRules(updateSyncRulesFromYaml('bucket_definitions: {}'));
+        const storage = f.getInstance(r.persisted_sync_rules);
+        await using writer = await storage.createWriter(test_utils.BATCH_OPTIONS);
+        await writer.markAllSnapshotDone('1/0');
+        await writer.keepalive('1/0');
+        await f.getStorageMetrics();
+        // We don't care about the specific values here
     });
     test('op_id initialization edge case', async () => {
-        const env_18 = { stack: [], error: void 0, hasError: false };
-        try {
-            // Test syncing a batch of data that is small in count,
-            // but large enough in size to be split over multiple returned chunks.
-            // Similar to the above test, but splits over 1MB chunks.
-            const factory = __addDisposableResource(env_18, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        // Test syncing a batch of data that is small in count,
+        // but large enough in size to be split over multiple returned chunks.
+        // Similar to the above test, but splits over 1MB chunks.
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
   bucket_definitions:
     global:
       data:
         - SELECT id FROM test
         - SELECT id FROM test_ignore WHERE false
   `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_18, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config, 1);
-            const sourceTableIgnore = await test_utils.resolveTestTable(writer, 'test_ignore', ['id'], config, 2);
-            await writer.markAllSnapshotDone('1/1');
-            // This saves a record to current_data, but not bucket_data.
-            // This causes a checkpoint to be created without increasing the op_id sequence.
-            await writer.save({
-                sourceTable: sourceTableIgnore,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            const result1 = await writer.flush();
-            const checkpoint1 = result1.flushed_op;
-            await writer.save({
-                sourceTable: sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test2'
-                },
-                afterReplicaId: test_utils.rid('test2')
-            });
-            const result2 = await writer.flush();
-            const checkpoint2 = result2.flushed_op;
-            // we expect 0n and 1n, or 1n and 2n.
-            expect(checkpoint2).toBeGreaterThan(checkpoint1);
-        }
-        catch (e_18) {
-            env_18.error = e_18;
-            env_18.hasError = true;
-        }
-        finally {
-            const result_18 = __disposeResources(env_18);
-            if (result_18)
-                await result_18;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config, 1);
+        const sourceTableIgnore = await test_utils.resolveTestTable(writer, 'test_ignore', ['id'], config, 2);
+        await writer.markAllSnapshotDone('1/1');
+        // This saves a record to current_data, but not bucket_data.
+        // This causes a checkpoint to be created without increasing the op_id sequence.
+        await writer.save({
+            sourceTable: sourceTableIgnore,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        const result1 = await writer.flush();
+        const checkpoint1 = result1.flushed_op;
+        await writer.save({
+            sourceTable: sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test2'
+            },
+            afterReplicaId: test_utils.rid('test2')
+        });
+        const result2 = await writer.flush();
+        const checkpoint2 = result2.flushed_op;
+        // we expect 0n and 1n, or 1n and 2n.
+        expect(checkpoint2).toBeGreaterThan(checkpoint1);
     });
     test('unchanged checksums', async () => {
-        const env_19 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_19, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT client_id as id, description FROM "%"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_19, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await writer.commit('1/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const request = bucketRequest(syncRules, 'global[]');
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
-            expect(checksums).toEqual([{ bucket: request.bucket, checksum: 1917136889, count: 1 }]);
-            const checksums2 = [...(await bucketStorage.getChecksums(checkpoint + 1n, [request])).values()];
-            expect(checksums2).toEqual([{ bucket: request.bucket, checksum: 1917136889, count: 1 }]);
-        }
-        catch (e_19) {
-            env_19.error = e_19;
-            env_19.hasError = true;
-        }
-        finally {
-            const result_19 = __disposeResources(env_19);
-            if (result_19)
-                await result_19;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
+        await writer.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await writer.commit('1/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        const request = bucketRequest(syncRules, 'global[]');
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, [request])).values()];
+        expect(checksums).toEqual([{ bucket: request.bucket, checksum: 1917136889, count: 1 }]);
+        const checksums2 = [...(await bucketStorage.getChecksums(checkpoint + 1n, [request])).values()];
+        expect(checksums2).toEqual([{ bucket: request.bucket, checksum: 1917136889, count: 1 }]);
     });
     testChecksumBatching(config);
     test('empty checkpoints (1)', async () => {
-        const env_20 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_20, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, { storageVersion }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_20, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.commit('1/1');
-            const cp1 = await bucketStorage.getCheckpoint();
-            expect(cp1.lsn).toEqual('1/1');
-            await writer.commit('2/1', { createEmptyCheckpoints: true });
-            const cp2 = await bucketStorage.getCheckpoint();
-            expect(cp2.lsn).toEqual('2/1');
-            await writer.keepalive('3/1');
-            const cp3 = await bucketStorage.getCheckpoint();
-            expect(cp3.lsn).toEqual('3/1');
-            // For the last one, we skip creating empty checkpoints
-            // This means the LSN stays at 3/1.
-            await writer.commit('4/1', { createEmptyCheckpoints: false });
-            const cp4 = await bucketStorage.getCheckpoint();
-            expect(cp4.lsn).toEqual('3/1');
-        }
-        catch (e_20) {
-            env_20.error = e_20;
-            env_20.hasError = true;
-        }
-        finally {
-            const result_20 = __disposeResources(env_20);
-            if (result_20)
-                await result_20;
-        }
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.commit('1/1');
+        const cp1 = await bucketStorage.getCheckpoint();
+        expect(cp1.lsn).toEqual('1/1');
+        await writer.commit('2/1', { createEmptyCheckpoints: true });
+        const cp2 = await bucketStorage.getCheckpoint();
+        expect(cp2.lsn).toEqual('2/1');
+        await writer.keepalive('3/1');
+        const cp3 = await bucketStorage.getCheckpoint();
+        expect(cp3.lsn).toEqual('3/1');
+        // For the last one, we skip creating empty checkpoints
+        // This means the LSN stays at 3/1.
+        await writer.commit('4/1', { createEmptyCheckpoints: false });
+        const cp4 = await bucketStorage.getCheckpoint();
+        expect(cp4.lsn).toEqual('3/1');
     });
     test('empty checkpoints (2)', async () => {
-        const env_21 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_21, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer1 = __addDisposableResource(env_21, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const writer2 = __addDisposableResource(env_21, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer2, 'test', ['id'], config);
-            // We simulate two concurrent batches, but sequential calls are enough for this test.
-            await writer1.markAllSnapshotDone('1/1');
-            await writer1.commit('1/1');
-            await writer1.commit('2/1', { createEmptyCheckpoints: false });
-            const cp2 = await bucketStorage.getCheckpoint();
-            expect(cp2.lsn).toEqual('1/1'); // checkpoint 2/1 skipped
-            await writer2.save({
-                sourceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            // This simulates what happens on a snapshot processor.
-            // This may later change to a flush() rather than commit().
-            await writer2.commit(test_utils.BATCH_OPTIONS.zeroLSN);
-            const cp3 = await bucketStorage.getCheckpoint();
-            expect(cp3.lsn).toEqual('1/1'); // Still unchanged
-            // This now needs to advance the LSN, despite {createEmptyCheckpoints: false}
-            await writer1.commit('4/1', { createEmptyCheckpoints: false });
-            const cp4 = await bucketStorage.getCheckpoint();
-            expect(cp4.lsn).toEqual('4/1');
-        }
-        catch (e_21) {
-            env_21.error = e_21;
-            env_21.hasError = true;
-        }
-        finally {
-            const result_21 = __disposeResources(env_21);
-            if (result_21)
-                await result_21;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer1 = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        await using writer2 = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const sourceTable = await test_utils.resolveTestTable(writer2, 'test', ['id'], config);
+        // We simulate two concurrent batches, but sequential calls are enough for this test.
+        await writer1.markAllSnapshotDone('1/1');
+        await writer1.commit('1/1');
+        await writer1.commit('2/1', { createEmptyCheckpoints: false });
+        const cp2 = await bucketStorage.getCheckpoint();
+        expect(cp2.lsn).toEqual('1/1'); // checkpoint 2/1 skipped
+        await writer2.save({
+            sourceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        // This simulates what happens on a snapshot processor.
+        // This may later change to a flush() rather than commit().
+        await writer2.commit(test_utils.BATCH_OPTIONS.zeroLSN);
+        const cp3 = await bucketStorage.getCheckpoint();
+        expect(cp3.lsn).toEqual('1/1'); // Still unchanged
+        // This now needs to advance the LSN, despite {createEmptyCheckpoints: false}
+        await writer1.commit('4/1', { createEmptyCheckpoints: false });
+        const cp4 = await bucketStorage.getCheckpoint();
+        expect(cp4.lsn).toEqual('4/1');
     });
     test('empty checkpoints (sync rule activation)', async () => {
-        const env_22 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_22, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_22, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const result1 = await writer.commit('1/1', { createEmptyCheckpoints: false });
-            expect(result1).toEqual({ checkpointBlocked: true, checkpointCreated: false });
-            // Snapshot is only valid once we reach 3/1
-            await writer.markAllSnapshotDone('3/1');
-            // 2/1 < 3/1 - snapshot not valid yet, block checkpoint
-            const result2 = await writer.commit('2/1', { createEmptyCheckpoints: false });
-            expect(result2).toEqual({ checkpointBlocked: true, checkpointCreated: false });
-            // No empty checkpoint should be created by the commit above.
-            const cp1 = await bucketStorage.getCheckpoint();
-            expect(cp1.lsn).toEqual(null);
-            // After this commit, the snapshot should be valid.
-            // We specifically check that this is done even if createEmptyCheckpoints: false.
-            const result3 = await writer.commit('3/1', { createEmptyCheckpoints: false });
-            expect(result3).toEqual({ checkpointBlocked: false, checkpointCreated: true });
-            // Now, the checkpoint should advance the sync rules active.
-            const cp2 = await bucketStorage.getCheckpoint();
-            expect(cp2.lsn).toEqual('3/1');
-            const activeSyncRules = await factory.getActiveSyncRulesContent();
-            expect(activeSyncRules?.id).toEqual(syncRules.id);
-            // At this point, it should be a truely empty checkpoint
-            const result4 = await writer.commit('4/1', { createEmptyCheckpoints: false });
-            expect(result4).toEqual({ checkpointBlocked: false, checkpointCreated: false });
-            // Unchanged
-            const cp3 = await bucketStorage.getCheckpoint();
-            expect(cp3.lsn).toEqual('3/1');
-        }
-        catch (e_22) {
-            env_22.error = e_22;
-            env_22.hasError = true;
-        }
-        finally {
-            const result_22 = __disposeResources(env_22);
-            if (result_22)
-                await result_22;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const result1 = await writer.commit('1/1', { createEmptyCheckpoints: false });
+        expect(result1).toEqual({ checkpointBlocked: true, checkpointCreated: false });
+        // Snapshot is only valid once we reach 3/1
+        await writer.markAllSnapshotDone('3/1');
+        // 2/1 < 3/1 - snapshot not valid yet, block checkpoint
+        const result2 = await writer.commit('2/1', { createEmptyCheckpoints: false });
+        expect(result2).toEqual({ checkpointBlocked: true, checkpointCreated: false });
+        // No empty checkpoint should be created by the commit above.
+        const cp1 = await bucketStorage.getCheckpoint();
+        expect(cp1.lsn).toEqual(null);
+        // After this commit, the snapshot should be valid.
+        // We specifically check that this is done even if createEmptyCheckpoints: false.
+        const result3 = await writer.commit('3/1', { createEmptyCheckpoints: false });
+        expect(result3).toEqual({ checkpointBlocked: false, checkpointCreated: true });
+        // Now, the checkpoint should advance the sync rules active.
+        const cp2 = await bucketStorage.getCheckpoint();
+        expect(cp2.lsn).toEqual('3/1');
+        const activeSyncRules = await factory.getActiveSyncRulesContent();
+        expect(activeSyncRules?.id).toEqual(syncRules.id);
+        // At this point, it should be a truely empty checkpoint
+        const result4 = await writer.commit('4/1', { createEmptyCheckpoints: false });
+        expect(result4).toEqual({ checkpointBlocked: false, checkpointCreated: false });
+        // Unchanged
+        const cp3 = await bucketStorage.getCheckpoint();
+        expect(cp3.lsn).toEqual('3/1');
     });
     test.runIf(storageVersion >= 3)('deleting while streaming', async () => {
-        const env_23 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_23, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const snapshotWriter = __addDisposableResource(env_23, await bucketStorage.createWriter({
-                ...test_utils.BATCH_OPTIONS,
-                skipExistingRows: true
-            }), true);
-            const streamingWriter = __addDisposableResource(env_23, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const snapshotTable = await test_utils.resolveTestTable(snapshotWriter, 'test', ['id'], config, 1);
-            const streamingTable = await test_utils.resolveTestTable(streamingWriter, 'test', ['id'], config, 1);
-            // We simulate two concurrent batches; separate writers are enough for this test.
-            // For this test, we assume that we start with a row "test1", which is picked up by a snapshot
-            // query, right before the delete is streamed. But the snapshot query is only persisted _after_
-            // the delete is streamed, and we need to ensure that the streamed delete takes precedence.
-            await streamingWriter.save({
-                sourceTable: streamingTable,
-                tag: storage.SaveOperationTag.DELETE,
-                before: {
-                    id: 'test1'
-                },
-                beforeReplicaId: test_utils.rid('test1')
-            });
-            await streamingWriter.commit('2/1');
-            await snapshotWriter.save({
-                sourceTable: snapshotTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'test1',
-                    description: 'test1a'
-                },
-                afterReplicaId: test_utils.rid('test1')
-            });
-            await snapshotWriter.markAllSnapshotDone('3/1');
-            await snapshotWriter.commit('1/1');
-            await streamingWriter.keepalive('3/1');
-            const cp = await bucketStorage.getCheckpoint();
-            expect(cp.lsn).toEqual('3/1');
-            const data = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(cp.checkpoint, [bucketRequest(syncRules, 'global[]')]));
-            expect(data).toEqual([]);
-        }
-        catch (e_23) {
-            env_23.error = e_23;
-            env_23.hasError = true;
-        }
-        finally {
-            const result_23 = __disposeResources(env_23);
-            if (result_23)
-                await result_23;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using snapshotWriter = await bucketStorage.createWriter({
+            ...test_utils.BATCH_OPTIONS,
+            skipExistingRows: true
+        });
+        await using streamingWriter = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const snapshotTable = await test_utils.resolveTestTable(snapshotWriter, 'test', ['id'], config, 1);
+        const streamingTable = await test_utils.resolveTestTable(streamingWriter, 'test', ['id'], config, 1);
+        // We simulate two concurrent batches; separate writers are enough for this test.
+        // For this test, we assume that we start with a row "test1", which is picked up by a snapshot
+        // query, right before the delete is streamed. But the snapshot query is only persisted _after_
+        // the delete is streamed, and we need to ensure that the streamed delete takes precedence.
+        await streamingWriter.save({
+            sourceTable: streamingTable,
+            tag: storage.SaveOperationTag.DELETE,
+            before: {
+                id: 'test1'
+            },
+            beforeReplicaId: test_utils.rid('test1')
+        });
+        await streamingWriter.commit('2/1');
+        await snapshotWriter.save({
+            sourceTable: snapshotTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'test1',
+                description: 'test1a'
+            },
+            afterReplicaId: test_utils.rid('test1')
+        });
+        await snapshotWriter.markAllSnapshotDone('3/1');
+        await snapshotWriter.commit('1/1');
+        await streamingWriter.keepalive('3/1');
+        const cp = await bucketStorage.getCheckpoint();
+        expect(cp.lsn).toEqual('3/1');
+        const data = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(cp.checkpoint, [bucketRequest(syncRules, 'global[]')]));
+        expect(data).toEqual([]);
     });
 }
 /**
@@ -1683,62 +1356,50 @@ bucket_definitions:
 export function testChecksumBatching(config) {
     const storageVersion = config.storageVersion ?? CURRENT_STORAGE_VERSION;
     test('checksums for multiple buckets', async () => {
-        const env_24 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_24, await config.factory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await config.factory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   user:
     parameters: select request.user_id() as user_id
     data:
       - select id, description from test where user_id = bucket.user_id
 `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_24, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            for (let u of ['u1', 'u2', 'u3', 'u4']) {
-                for (let t of ['t1', 't2', 't3', 't4']) {
-                    const id = `${t}_${u}`;
-                    await writer.save({
-                        sourceTable,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id,
-                            description: `${t} description`,
-                            user_id: u
-                        },
-                        afterReplicaId: test_utils.rid(id)
-                    });
-                }
+            storageVersion
+        }));
+        const bucketStorage = factory.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('1/1');
+        for (let u of ['u1', 'u2', 'u3', 'u4']) {
+            for (let t of ['t1', 't2', 't3', 't4']) {
+                const id = `${t}_${u}`;
+                await writer.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id,
+                        description: `${t} description`,
+                        user_id: u
+                    },
+                    afterReplicaId: test_utils.rid(id)
+                });
             }
-            await writer.commit('1/1');
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            bucketStorage.clearChecksumCache();
-            const users = ['u1', 'u2', 'u3', 'u4'];
-            const expectedChecksums = [346204588, 5261081, 134760718, -302639724];
-            const bucketRequests = users.map((user) => bucketRequest(syncRules, `user["${user}"]`));
-            const checksums = [...(await bucketStorage.getChecksums(checkpoint, bucketRequests)).values()];
-            checksums.sort((a, b) => a.bucket.localeCompare(b.bucket));
-            const expected = bucketRequests.map((request, index) => ({
-                bucket: request.bucket,
-                count: 4,
-                checksum: expectedChecksums[index]
-            }));
-            expected.sort((a, b) => a.bucket.localeCompare(b.bucket));
-            expect(checksums).toEqual(expected);
-        }
-        catch (e_24) {
-            env_24.error = e_24;
-            env_24.hasError = true;
-        }
-        finally {
-            const result_24 = __disposeResources(env_24);
-            if (result_24)
-                await result_24;
         }
+        await writer.commit('1/1');
+        const { checkpoint } = await bucketStorage.getCheckpoint();
+        bucketStorage.clearChecksumCache();
+        const users = ['u1', 'u2', 'u3', 'u4'];
+        const expectedChecksums = [346204588, 5261081, 134760718, -302639724];
+        const bucketRequests = users.map((user) => bucketRequest(syncRules, `user["${user}"]`));
+        const checksums = [...(await bucketStorage.getChecksums(checkpoint, bucketRequests)).values()];
+        checksums.sort((a, b) => a.bucket.localeCompare(b.bucket));
+        const expected = bucketRequests.map((request, index) => ({
+            bucket: request.bucket,
+            count: 4,
+            checksum: expectedChecksums[index]
+        }));
+        expected.sort((a, b) => a.bucket.localeCompare(b.bucket));
+        expect(checksums).toEqual(expected);
     });
 }
 //# sourceMappingURL=register-data-storage-data-tests.js.map