@powersync/service-core 1.19.2 → 1.20.1

package/test/src/sync/BucketChecksumState.test.ts

@@ -13,11 +13,44 @@ import {
   WatchFilterEvent
 } from '@/index.js';
 import { JSONBig } from '@powersync/service-jsonbig';
-import { RequestJwtPayload, ScopedParameterLookup, SqliteJsonRow, SqlSyncRules } from '@powersync/service-sync-rules';
-import { versionedHydrationState } from '@powersync/service-sync-rules/src/HydrationState.js';
+import {
+  ParameterIndexLookupCreator,
+  RequestJwtPayload,
+  ScopedParameterLookup,
+  SqliteJsonRow,
+  SqliteRow,
+  SqlSyncRules,
+  TablePattern,
+  SourceTableInterface,
+  versionedHydrationState
+} from '@powersync/service-sync-rules';
+import { ParameterLookupScope } from '@powersync/service-sync-rules/src/HydrationState.js';
 import { beforeEach, describe, expect, test } from 'vitest';
 
 describe('BucketChecksumState', () => {
+  const LOOKUP_SOURCE: ParameterIndexLookupCreator = {
+    get defaultLookupScope(): ParameterLookupScope {
+      return {
+        lookupName: 'lookup',
+        queryId: '0',
+        source: LOOKUP_SOURCE
+      };
+    },
+    getSourceTables(): Set<TablePattern> {
+      return new Set();
+    },
+    evaluateParameterRow(_sourceTable: SourceTableInterface, _row: SqliteRow) {
+      return [];
+    },
+    tableSyncsParameters(_table: SourceTableInterface): boolean {
+      return false;
+    }
+  };
+
+  function lookupScope(lookupName: string, queryId: string): ParameterLookupScope {
+    return { lookupName, queryId, source: LOOKUP_SOURCE };
+  }
+
   // Single global[] bucket.
   // We don't care about data in these tests
   const SYNC_RULES_GLOBAL = SqlSyncRules.fromYaml(
@@ -62,10 +95,14 @@ bucket_definitions:
   const syncRequest: StreamingSyncRequest = {};
   const tokenPayload = new JwtPayload({ sub: '' });
 
+  function bucketStarts(requests: { bucket: string; start: InternalOpId }[]) {
+    return new Map(requests.map((request) => [request.bucket, request.start]));
+  }
+
   test('global bucket with update', async () => {
     const storage = new MockBucketChecksumStateStorage();
     // Set intial state
-    storage.updateTestChecksum({ bucket: 'global[]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '1#global[]', checksum: 1, count: 1 });
 
     const state = new BucketChecksumState({
       syncContext,
@@ -83,34 +120,34 @@ bucket_definitions:
     line.advance();
     expect(line.checkpointLine).toEqual({
       checkpoint: {
-        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
+        buckets: [{ bucket: '1#global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
         last_op_id: '1',
         write_checkpoint: undefined,
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
-        bucket: 'global[]',
+        bucket: '1#global[]',
         priority: 3
       }
     ]);
     // This is the bucket data to be fetched
-    expect(line.getFilteredBucketPositions()).toEqual(new Map([['global[]', 0n]]));
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 0n]]));
 
     // This similuates the bucket data being sent
     line.advance();
-    line.updateBucketPosition({ bucket: 'global[]', nextAfter: 1n, hasMore: false });
+    line.updateBucketPosition({ bucket: '1#global[]', nextAfter: 1n, hasMore: false });
 
     // Update bucket storage state
-    storage.updateTestChecksum({ bucket: 'global[]', checksum: 2, count: 2 });
+    storage.updateTestChecksum({ bucket: '1#global[]', checksum: 2, count: 2 });
 
     // Now we get a new line
     const line2 = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(2n),
       writeCheckpoint: null,
       update: {
-        updatedDataBuckets: new Set(['global[]']),
+        updatedDataBuckets: new Set(['1#global[]']),
         invalidateDataBuckets: false,
         updatedParameterLookups: new Set(),
         invalidateParameterBuckets: false
@@ -120,12 +157,14 @@ bucket_definitions:
     expect(line2.checkpointLine).toEqual({
       checkpoint_diff: {
         removed_buckets: [],
-        updated_buckets: [{ bucket: 'global[]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }],
+        updated_buckets: [
+          { bucket: '1#global[]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
+        ],
         last_op_id: '2',
         write_checkpoint: undefined
       }
     });
-    expect(line2.getFilteredBucketPositions()).toEqual(new Map([['global[]', 1n]]));
+    expect(bucketStarts(line2.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 1n]]));
   });
 
   test('global bucket with initial state', async () => {
@@ -134,13 +173,13 @@ bucket_definitions:
     /// (getFilteredBucketStates)
     const storage = new MockBucketChecksumStateStorage();
     // Set intial state
-    storage.updateTestChecksum({ bucket: 'global[]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '1#global[]', checksum: 1, count: 1 });
 
     const state = new BucketChecksumState({
       syncContext,
       tokenPayload,
       // Client sets the initial state here
-      syncRequest: { buckets: [{ name: 'global[]', after: '1' }] },
+      syncRequest: { buckets: [{ name: '1#global[]', after: '1' }] },
       syncRules: SYNC_RULES_GLOBAL,
       bucketStorage: storage
     });
@@ -153,27 +192,27 @@ bucket_definitions:
     line.advance();
     expect(line.checkpointLine).toEqual({
       checkpoint: {
-        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
+        buckets: [{ bucket: '1#global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
         last_op_id: '1',
         write_checkpoint: undefined,
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
-        bucket: 'global[]',
+        bucket: '1#global[]',
         priority: 3
       }
     ]);
     // This is the main difference between this and the previous test
-    expect(line.getFilteredBucketPositions()).toEqual(new Map([['global[]', 1n]]));
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 1n]]));
   });
 
   test('multiple static buckets', async () => {
     const storage = new MockBucketChecksumStateStorage();
     // Set intial state
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 1, count: 1 });
-    storage.updateTestChecksum({ bucket: 'global[2]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '2#global[2]', checksum: 1, count: 1 });
 
     const state = new BucketChecksumState({
       syncContext,
@@ -191,35 +230,35 @@ bucket_definitions:
     expect(line.checkpointLine).toEqual({
       checkpoint: {
         buckets: [
-          { bucket: 'global[1]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] },
-          { bucket: 'global[2]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }
+          { bucket: '2#global[1]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: '2#global[2]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '1',
         write_checkpoint: undefined,
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
-        bucket: 'global[1]',
+        bucket: '2#global[1]',
         priority: 3
       },
       {
-        bucket: 'global[2]',
+        bucket: '2#global[2]',
         priority: 3
       }
     ]);
     line.advance();
 
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 2, count: 2 });
-    storage.updateTestChecksum({ bucket: 'global[2]', checksum: 2, count: 2 });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 2, count: 2 });
+    storage.updateTestChecksum({ bucket: '2#global[2]', checksum: 2, count: 2 });
 
     const line2 = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(2n),
       writeCheckpoint: null,
       update: {
         ...CHECKPOINT_INVALIDATE_ALL,
-        updatedDataBuckets: new Set(['global[1]', 'global[2]']),
+        updatedDataBuckets: new Set(['2#global[1]', '2#global[2]']),
         invalidateDataBuckets: false
       }
     }))!;
@@ -227,8 +266,8 @@ bucket_definitions:
       checkpoint_diff: {
         removed_buckets: [],
         updated_buckets: [
-          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] },
-          { bucket: 'global[2]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
+          { bucket: '2#global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: '2#global[2]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '2',
         write_checkpoint: undefined
@@ -251,7 +290,7 @@ bucket_definitions:
       bucketStorage: storage
     });
 
-    storage.updateTestChecksum({ bucket: 'global[]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '1#global[]', checksum: 1, count: 1 });
 
     const line = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(1n),
@@ -261,19 +300,19 @@ bucket_definitions:
     line.advance();
     expect(line.checkpointLine).toEqual({
       checkpoint: {
-        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
+        buckets: [{ bucket: '1#global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
         last_op_id: '1',
         write_checkpoint: undefined,
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
-        bucket: 'global[]',
+        bucket: '1#global[]',
         priority: 3
       }
     ]);
-    expect(line.getFilteredBucketPositions()).toEqual(new Map([['global[]', 0n]]));
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 0n]]));
   });
 
   test('invalidating individual bucket', async () => {
@@ -281,8 +320,8 @@ bucket_definitions:
 
     const storage = new MockBucketChecksumStateStorage();
     // Set initial state
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 1, count: 1 });
-    storage.updateTestChecksum({ bucket: 'global[2]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '2#global[2]', checksum: 1, count: 1 });
 
     const state = new BucketChecksumState({
       syncContext,
@@ -301,11 +340,11 @@ bucket_definitions:
       update: CHECKPOINT_INVALIDATE_ALL
     });
     line!.advance();
-    line!.updateBucketPosition({ bucket: 'global[1]', nextAfter: 1n, hasMore: false });
-    line!.updateBucketPosition({ bucket: 'global[2]', nextAfter: 1n, hasMore: false });
+    line!.updateBucketPosition({ bucket: '2#global[1]', nextAfter: 1n, hasMore: false });
+    line!.updateBucketPosition({ bucket: '2#global[2]', nextAfter: 1n, hasMore: false });
 
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 2, count: 2 });
-    storage.updateTestChecksum({ bucket: 'global[2]', checksum: 2, count: 2 });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 2, count: 2 });
+    storage.updateTestChecksum({ bucket: '2#global[2]', checksum: 2, count: 2 });
 
     const line2 = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(2n),
@@ -315,7 +354,7 @@ bucket_definitions:
         // Invalidate the state for global[1] - will only re-check the single bucket.
         // This is essentially inconsistent state, but is the simplest way to test that
         // the filter is working.
-        updatedDataBuckets: new Set(['global[1]']),
+        updatedDataBuckets: new Set(['2#global[1]']),
         invalidateDataBuckets: false
       }
     }))!;
@@ -324,13 +363,13 @@ bucket_definitions:
         removed_buckets: [],
         updated_buckets: [
           // This does not include global[2], since it was not invalidated.
-          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
+          { bucket: '2#global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '2',
         write_checkpoint: undefined
       }
     });
-    expect(line2.bucketsToFetch).toEqual([{ bucket: 'global[1]', priority: 3 }]);
+    expect(line2.bucketsToFetch).toMatchObject([{ bucket: '2#global[1]', priority: 3 }]);
   });
 
   test('invalidating all buckets', async () => {
@@ -349,8 +388,8 @@ bucket_definitions:
     // storage.filter = state.checkpointFilter;
 
     // Set initial state
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 1, count: 1 });
-    storage.updateTestChecksum({ bucket: 'global[2]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '2#global[2]', checksum: 1, count: 1 });
 
     const line = await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(1n),
@@ -360,8 +399,8 @@ bucket_definitions:
 
     line!.advance();
 
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 2, count: 2 });
-    storage.updateTestChecksum({ bucket: 'global[2]', checksum: 2, count: 2 });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 2, count: 2 });
+    storage.updateTestChecksum({ bucket: '2#global[2]', checksum: 2, count: 2 });
 
     const line2 = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(2n),
@@ -373,24 +412,24 @@ bucket_definitions:
       checkpoint_diff: {
         removed_buckets: [],
         updated_buckets: [
-          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] },
-          { bucket: 'global[2]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
+          { bucket: '2#global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: '2#global[2]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '2',
         write_checkpoint: undefined
       }
     });
-    expect(line2.bucketsToFetch).toEqual([
-      { bucket: 'global[1]', priority: 3 },
-      { bucket: 'global[2]', priority: 3 }
+    expect(line2.bucketsToFetch).toMatchObject([
+      { bucket: '2#global[1]', priority: 3 },
+      { bucket: '2#global[2]', priority: 3 }
     ]);
   });
 
   test('interrupt and resume static buckets checkpoint', async () => {
     const storage = new MockBucketChecksumStateStorage();
     // Set intial state
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 3, count: 3 });
-    storage.updateTestChecksum({ bucket: 'global[2]', checksum: 3, count: 3 });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 3, count: 3 });
+    storage.updateTestChecksum({ bucket: '2#global[2]', checksum: 3, count: 3 });
 
     const state = new BucketChecksumState({
       syncContext,
@@ -409,39 +448,39 @@ bucket_definitions:
     expect(line.checkpointLine).toEqual({
       checkpoint: {
         buckets: [
-          { bucket: 'global[1]', checksum: 3, count: 3, priority: 3, subscriptions: [{ default: 0 }] },
-          { bucket: 'global[2]', checksum: 3, count: 3, priority: 3, subscriptions: [{ default: 0 }] }
+          { bucket: '2#global[1]', checksum: 3, count: 3, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: '2#global[2]', checksum: 3, count: 3, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '3',
         write_checkpoint: undefined,
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
-        bucket: 'global[1]',
+        bucket: '2#global[1]',
         priority: 3
       },
       {
-        bucket: 'global[2]',
+        bucket: '2#global[2]',
         priority: 3
       }
     ]);
 
     // This is the bucket data to be fetched
-    expect(line.getFilteredBucketPositions()).toEqual(
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(
       new Map([
-        ['global[1]', 0n],
-        ['global[2]', 0n]
+        ['2#global[1]', 0n],
+        ['2#global[2]', 0n]
       ])
     );
 
     // No data changes here.
     // We simulate partial data sent, before a checkpoint is interrupted.
     line.advance();
-    line.updateBucketPosition({ bucket: 'global[1]', nextAfter: 3n, hasMore: false });
-    line.updateBucketPosition({ bucket: 'global[2]', nextAfter: 1n, hasMore: true });
-    storage.updateTestChecksum({ bucket: 'global[1]', checksum: 4, count: 4 });
+    line.updateBucketPosition({ bucket: '2#global[1]', nextAfter: 3n, hasMore: false });
+    line.updateBucketPosition({ bucket: '2#global[2]', nextAfter: 1n, hasMore: true });
+    storage.updateTestChecksum({ bucket: '2#global[1]', checksum: 4, count: 4 });
 
     const line2 = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(4n),
@@ -449,7 +488,7 @@ bucket_definitions:
       update: {
         ...CHECKPOINT_INVALIDATE_ALL,
         invalidateDataBuckets: false,
-        updatedDataBuckets: new Set(['global[1]'])
+        updatedDataBuckets: new Set(['2#global[1]'])
       }
     }))!;
     line2.advance();
@@ -458,7 +497,7 @@ bucket_definitions:
         removed_buckets: [],
         updated_buckets: [
           {
-            bucket: 'global[1]',
+            bucket: '2#global[1]',
             checksum: 4,
             count: 4,
             priority: 3,
@@ -470,21 +509,21 @@ bucket_definitions:
       }
     });
     // This should contain both buckets, even though only one changed.
-    expect(line2.bucketsToFetch).toEqual([
+    expect(line2.bucketsToFetch).toMatchObject([
       {
-        bucket: 'global[1]',
+        bucket: '2#global[1]',
         priority: 3
       },
       {
-        bucket: 'global[2]',
+        bucket: '2#global[2]',
         priority: 3
       }
     ]);
 
-    expect(line2.getFilteredBucketPositions()).toEqual(
+    expect(bucketStarts(line2.getFilteredBucketPositions())).toEqual(
       new Map([
-        ['global[1]', 3n],
-        ['global[2]', 1n]
+        ['2#global[1]', 3n],
+        ['2#global[2]', 1n]
       ])
     );
   });
@@ -492,9 +531,9 @@ bucket_definitions:
   test('dynamic buckets with updates', async () => {
     const storage = new MockBucketChecksumStateStorage();
     // Set intial state
-    storage.updateTestChecksum({ bucket: 'by_project[1]', checksum: 1, count: 1 });
-    storage.updateTestChecksum({ bucket: 'by_project[2]', checksum: 1, count: 1 });
-    storage.updateTestChecksum({ bucket: 'by_project[3]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '3#by_project[1]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '3#by_project[2]', checksum: 1, count: 1 });
+    storage.updateTestChecksum({ bucket: '3#by_project[3]', checksum: 1, count: 1 });
 
     const state = new BucketChecksumState({
       syncContext,
@@ -506,7 +545,7 @@ bucket_definitions:
 
     const line = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(1n, (lookups) => {
-        expect(lookups).toEqual([ScopedParameterLookup.direct({ lookupName: 'by_project', queryId: '1' }, ['u1'])]);
+        expect(lookups).toEqual([ScopedParameterLookup.direct(lookupScope('by_project', '1'), ['u1'])]);
         return [{ id: 1 }, { id: 2 }];
       }),
       writeCheckpoint: null,
@@ -516,14 +555,14 @@ bucket_definitions:
       checkpoint: {
         buckets: [
           {
-            bucket: 'by_project[1]',
+            bucket: '3#by_project[1]',
             checksum: 1,
             count: 1,
             priority: 3,
             subscriptions: [{ default: 0 }]
           },
           {
-            bucket: 'by_project[2]',
+            bucket: '3#by_project[2]',
             checksum: 1,
             count: 1,
             priority: 3,
@@ -541,33 +580,33 @@ bucket_definitions:
         write_checkpoint: undefined
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
-        bucket: 'by_project[1]',
+        bucket: '3#by_project[1]',
         priority: 3
       },
       {
-        bucket: 'by_project[2]',
+        bucket: '3#by_project[2]',
         priority: 3
       }
     ]);
     line.advance();
     // This is the bucket data to be fetched
-    expect(line.getFilteredBucketPositions()).toEqual(
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(
       new Map([
-        ['by_project[1]', 0n],
-        ['by_project[2]', 0n]
+        ['3#by_project[1]', 0n],
+        ['3#by_project[2]', 0n]
       ])
     );
 
     line.advance();
-    line.updateBucketPosition({ bucket: 'by_project[1]', nextAfter: 1n, hasMore: false });
-    line.updateBucketPosition({ bucket: 'by_project[2]', nextAfter: 1n, hasMore: false });
+    line.updateBucketPosition({ bucket: '3#by_project[1]', nextAfter: 1n, hasMore: false });
+    line.updateBucketPosition({ bucket: '3#by_project[2]', nextAfter: 1n, hasMore: false });
 
     // Now we get a new line
     const line2 = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(2n, (lookups) => {
-        expect(lookups).toEqual([ScopedParameterLookup.direct({ lookupName: 'by_project', queryId: '1' }, ['u1'])]);
+        expect(lookups).toEqual([ScopedParameterLookup.direct(lookupScope('by_project', '1'), ['u1'])]);
         return [{ id: 1 }, { id: 2 }, { id: 3 }];
       }),
       writeCheckpoint: null,
@@ -584,7 +623,7 @@ bucket_definitions:
         removed_buckets: [],
         updated_buckets: [
           {
-            bucket: 'by_project[3]',
+            bucket: '3#by_project[3]',
             checksum: 1,
             count: 1,
             priority: 3,
@@ -595,7 +634,7 @@ bucket_definitions:
         write_checkpoint: undefined
       }
     });
-    expect(line2.getFilteredBucketPositions()).toEqual(new Map([['by_project[3]', 0n]]));
+    expect(bucketStarts(line2.getFilteredBucketPositions())).toEqual(new Map([['3#by_project[3]', 0n]]));
   });
 
   describe('streams', () => {
@@ -820,6 +859,206 @@ config:
       });
     });
   });
+
+  describe('parameter query result logging', () => {
+    test('logs parameter query results for dynamic buckets', async () => {
+      const storage = new MockBucketChecksumStateStorage();
+      storage.updateTestChecksum({ bucket: 'by_project[1]', checksum: 1, count: 1 });
+      storage.updateTestChecksum({ bucket: 'by_project[2]', checksum: 1, count: 1 });
+      storage.updateTestChecksum({ bucket: 'by_project[3]', checksum: 1, count: 1 });
+
+      const logMessages: string[] = [];
+      const logData: any[] = [];
+      const mockLogger = {
+        info: (message: string, data: any) => {
+          logMessages.push(message);
+          logData.push(data);
+        },
+        error: () => {},
+        warn: () => {},
+        debug: () => {}
+      };
+
+      const state = new BucketChecksumState({
+        syncContext,
+        tokenPayload: new JwtPayload({ sub: 'u1' }),
+        syncRequest,
+        syncRules: SYNC_RULES_DYNAMIC,
+        bucketStorage: storage,
+        logger: mockLogger as any
+      });
+
+      const line = (await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n, (lookups) => {
+          return [{ id: 1 }, { id: 2 }, { id: 3 }];
+        }),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      }))!;
+      line.advance();
+
+      expect(logMessages[0]).toContain('param_results: 3');
+      expect(logData[0].parameter_query_results).toBe(3);
+    });
+
+    test('throws error with breakdown when parameter query limit is exceeded', async () => {
+      const SYNC_RULES_MULTI = SqlSyncRules.fromYaml(
+        `
+bucket_definitions:
+  projects:
+    parameters: select id from projects where user_id = request.user_id()
+    data: []
+  tasks:
+    parameters: select id from tasks where user_id = request.user_id()
+    data: []
+  comments:
+    parameters: select id from comments where user_id = request.user_id()
+    data: []
+    `,
+        { defaultSchema: 'public' }
+      ).config.hydrate({ hydrationState: versionedHydrationState(4) });
+
+      const storage = new MockBucketChecksumStateStorage();
+
+      const errorMessages: string[] = [];
+      const errorData: any[] = [];
+      const mockLogger = {
+        info: () => {},
+        error: (message: string, data: any) => {
+          errorMessages.push(message);
+          errorData.push(data);
+        },
+        warn: () => {},
+        debug: () => {}
+      };
+
+      const smallContext = new SyncContext({
+        maxBuckets: 100,
+        maxParameterQueryResults: 50,
+        maxDataFetchConcurrency: 10
+      });
+
+      const state = new BucketChecksumState({
+        syncContext: smallContext,
+        tokenPayload: new JwtPayload({ sub: 'u1' }),
+        syncRequest,
+        syncRules: SYNC_RULES_MULTI,
+        bucketStorage: storage,
+        logger: mockLogger as any
+      });
+
+      // Create 60 total results: 30 projects + 20 tasks + 10 comments
+      const projectIds = Array.from({ length: 30 }, (_, i) => ({ id: i + 1 }));
+      const taskIds = Array.from({ length: 20 }, (_, i) => ({ id: i + 1 }));
+      const commentIds = Array.from({ length: 10 }, (_, i) => ({ id: i + 1 }));
+
+      for (let i = 1; i <= 30; i++) {
+        storage.updateTestChecksum({ bucket: `projects[${i}]`, checksum: 1, count: 1 });
+      }
+      for (let i = 1; i <= 20; i++) {
+        storage.updateTestChecksum({ bucket: `tasks[${i}]`, checksum: 1, count: 1 });
+      }
+      for (let i = 1; i <= 10; i++) {
+        storage.updateTestChecksum({ bucket: `comments[${i}]`, checksum: 1, count: 1 });
+      }
+
+      await expect(
+        state.buildNextCheckpointLine({
+          base: storage.makeCheckpoint(1n, (lookups) => {
+            const lookup = lookups[0];
+            const lookupName = lookup.values[0];
+            if (lookupName === 'projects') {
+              return projectIds;
+            } else if (lookupName === 'tasks') {
+              return taskIds;
+            } else {
+              return commentIds;
+            }
+          }),
+          writeCheckpoint: null,
+          update: CHECKPOINT_INVALIDATE_ALL
+        })
+      ).rejects.toThrow('Too many parameter query results: 60 (limit of 50)');
+
+      // Verify error log includes breakdown
+      expect(errorMessages[0]).toContain('Parameter query results by definition:');
+      expect(errorMessages[0]).toContain('projects: 30');
+      expect(errorMessages[0]).toContain('tasks: 20');
+      expect(errorMessages[0]).toContain('comments: 10');
+
+      expect(errorData[0].parameter_query_results).toBe(60);
+      expect(errorData[0].parameter_query_results_by_definition).toEqual({
+        projects: 30,
+        tasks: 20,
+        comments: 10
+      });
+    });
+
+    test('limits breakdown to top 10 definitions', async () => {
+      // Create sync rules with 15 different definitions with dynamic parameters
+      let yamlDefinitions = 'bucket_definitions:\n';
+      for (let i = 1; i <= 15; i++) {
+        yamlDefinitions += `  def${i}:\n`;
+        yamlDefinitions += `    parameters: select id from def${i}_table where user_id = request.user_id()\n`;
+        yamlDefinitions += `    data: []\n`;
+      }
+
+      const SYNC_RULES_MANY = SqlSyncRules.fromYaml(yamlDefinitions, { defaultSchema: 'public' }).config.hydrate({
+        hydrationState: versionedHydrationState(5)
+      });
+
+      const storage = new MockBucketChecksumStateStorage();
+
+      const errorMessages: string[] = [];
+      const mockLogger = {
+        info: () => {},
+        error: (message: string) => {
+          errorMessages.push(message);
+        },
+        warn: () => {},
+        debug: () => {}
+      };
+
+      const smallContext = new SyncContext({
+        maxBuckets: 100,
+        maxParameterQueryResults: 10,
+        maxDataFetchConcurrency: 10
+      });
+
+      const state = new BucketChecksumState({
+        syncContext: smallContext,
+        tokenPayload: new JwtPayload({ sub: 'u1' }),
+        syncRequest,
+        syncRules: SYNC_RULES_MANY,
+        bucketStorage: storage,
+        logger: mockLogger as any
+      });
+
+      // Each definition creates one bucket, total 15 buckets
+      for (let i = 1; i <= 15; i++) {
+        storage.updateTestChecksum({ bucket: `def${i}[${i}]`, checksum: 1, count: 1 });
+      }
+
+      await expect(
+        state.buildNextCheckpointLine({
+          base: storage.makeCheckpoint(1n, (lookups) => {
+            // Return one result for each definition
+            return [{ id: 1 }];
+          }),
+          writeCheckpoint: null,
+          update: CHECKPOINT_INVALIDATE_ALL
+        })
+      ).rejects.toThrow('Too many parameter query results: 15 (limit of 10)');
+
+      // Verify only top 10 are shown
+      const errorMessage = errorMessages[0];
+      expect(errorMessage).toContain('... and 5 more results from 5 definitions');
+
+      // Count how many definitions are listed (should be exactly 10)
+      const defMatches = errorMessage.match(/def\d+:/g);
+      expect(defMatches?.length).toBe(10);
+    });
+  });
 });
 
 class MockBucketChecksumStateStorage implements BucketChecksumStateStorage {
@@ -837,9 +1076,9 @@ class MockBucketChecksumStateStorage implements BucketChecksumStateStorage {
     this.filter?.({ invalidate: true });
   }
 
-  async getChecksums(checkpoint: InternalOpId, buckets: string[]): Promise<ChecksumMap> {
+  async getChecksums(_checkpoint: InternalOpId, buckets: { bucket: string }[]): Promise<ChecksumMap> {
     return new Map<string, BucketChecksum>(
-      buckets.map((bucket) => {
+      buckets.map(({ bucket }) => {
         const checksum = this.state.get(bucket);
         return [
           bucket,