@syncular/client 0.0.4-26 → 0.0.6-100

package/src/engine/SyncEngine.ts

@@ -18,6 +18,8 @@ import {
   startSyncSpan,
 } from '@syncular/core';
 import { type Kysely, sql, type Transaction } from 'kysely';
+import { getClientHandler } from '../handlers/collection';
+import { ensureClientSyncSchema } from '../migrate';
 import { syncPushOnce } from '../push-engine';
 import type {
   ConflictResultStatus,
@@ -1005,7 +1007,7 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
     }
 
     if (options.scope === 'all') {
-      for (const handler of this.config.handlers.getAll()) {
+      for (const handler of this.config.handlers) {
         await handler.clearAll({ trx, scopes: {} });
         clearedTables.push(handler.table);
       }
@@ -1014,7 +1016,7 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
 
     const seen = new Set<string>();
     for (const target of targets) {
-      const handler = this.config.handlers.get(target.table);
+      const handler = getClientHandler(this.config.handlers, target.table);
       if (!handler) continue;
 
       const key = `${target.table}:${JSON.stringify(target.scopes)}`;
@@ -1220,40 +1222,44 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
 
     this.updateState({ enabled: true });
 
-    // Run migration if provided
-    if (this.config.migrate && !this.migrated) {
-      // Best-effort: push any pending outbox commits before migration
-      // (migration may reset the DB, so we try to save unsynced changes)
-      try {
-        const hasOutbox = await sql`
-          select 1 from ${sql.table('sync_outbox_commits')} limit 1
-        `
-          .execute(this.config.db)
-          .then((r) => r.rows.length > 0)
-          .catch(() => false);
-
-        if (hasOutbox) {
-          // Push all pending commits (best effort)
-          let pushed = true;
-          while (pushed) {
-            const result = await syncPushOnce(
-              this.config.db,
-              this.config.transport,
-              {
-                clientId: this.config.clientId!,
-                actorId: this.config.actorId ?? undefined,
-                plugins: this.config.plugins,
-              }
-            );
-            pushed = result.pushed;
+    // Run migrations before first sync.
+    if (!this.migrated) {
+      // Best-effort: push pending commits before user migration, because
+      // app migrations may reset tables and discard unsynced local writes.
+      if (this.config.migrate) {
+        try {
+          const hasOutbox = await sql`
+            select 1 from ${sql.table('sync_outbox_commits')} limit 1
+          `
+            .execute(this.config.db)
+            .then((r) => r.rows.length > 0)
+            .catch(() => false);
+
+          if (hasOutbox) {
+            let pushed = true;
+            while (pushed) {
+              const result = await syncPushOnce(
+                this.config.db,
+                this.config.transport,
+                {
+                  clientId: this.config.clientId!,
+                  actorId: this.config.actorId ?? undefined,
+                  plugins: this.config.plugins,
+                }
+              );
+              pushed = result.pushed;
+            }
           }
+        } catch {
+          // Best-effort: continue even if pre-migration push fails.
         }
-      } catch {
-        // Best-effort: if push fails (network down, table missing), continue
       }
 
       try {
-        await this.config.migrate(this.config.db);
+        if (this.config.migrate) {
+          await this.config.migrate(this.config.db);
+        }
+        await ensureClientSyncSchema(this.config.db);
         this.migrated = true;
       } catch (err) {
         const migrationError =
@@ -1597,7 +1603,7 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
     try {
       await this.config.db.transaction().execute(async (trx) => {
         for (const change of changes) {
-          const handler = this.config.handlers.get(change.table);
+          const handler = getClientHandler(this.config.handlers, change.table);
           if (!handler) {
             throw new Error(
               `Missing client table handler for WS change table "${change.table}"`
@@ -1852,6 +1858,13 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
     }
 
     const delay = calculateRetryDelay(this.state.retryCount);
+    if (this.state.pendingCount > 0) {
+      countSyncMetric('sync.outbox.retry_count', 1, {
+        attributes: {
+          retryCount: this.state.retryCount,
+        },
+      });
+    }
     this.updateState({ isRetrying: true });
 
     this.retryTimeoutId = setTimeout(() => {
@@ -1975,6 +1988,13 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
           case 'connected': {
             const wasConnectedBefore = this.hasRealtimeConnectedOnce;
             this.hasRealtimeConnectedOnce = true;
+            if (wasConnectedBefore) {
+              countSyncMetric('sync.transport.reconnects', 1, {
+                attributes: {
+                  source: 'client',
+                },
+              });
+            }
             this.setConnectionState('connected');
             this.updateTransportHealth({
               mode: 'realtime',
@@ -2287,7 +2307,7 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
 
     await db.transaction().execute(async (trx) => {
       for (const input of inputs) {
-        const handler = handlers.get(input.table);
+        const handler = getClientHandler(handlers, input.table);
         if (!handler) continue;
 
         affectedTables.add(input.table);

package/src/engine/types.ts

@@ -12,7 +12,7 @@ import type {
   SyncTransport,
 } from '@syncular/core';
 import type { Kysely } from 'kysely';
-import type { ClientTableRegistry } from '../handlers/registry';
+import type { ClientHandlerCollection } from '../handlers/collection';
 import type { SyncClientPlugin } from '../plugins/types';
 import type { SyncClientDb } from '../schema';
 import type { SubscriptionState } from '../subscription-state';
@@ -225,7 +225,7 @@ export interface SyncEngineConfig<DB extends SyncClientDb = SyncClientDb> {
   /** Sync transport */
   transport: SyncTransport;
   /** Client table handler registry */
-  handlers: ClientTableRegistry<DB>;
+  handlers: ClientHandlerCollection<DB>;
   /** Actor id for sync scoping (null/undefined disables sync) */
   actorId: string | null | undefined;
   /** Stable device/app installation id */
@@ -244,7 +244,7 @@ export interface SyncEngineConfig<DB extends SyncClientDb = SyncClientDb> {
   pollIntervalMs?: number;
   /** Max retries before giving up */
   maxRetries?: number;
-  /** Migration function to run before first sync */
+  /** Optional app migration to run before sync schema migration. */
   migrate?: (db: Kysely<DB>) => Promise<void>;
   /** Called when migration fails. Receives the error. */
   onMigrationError?: (error: Error) => void;

package/src/handlers/collection.ts

@@ -0,0 +1,36 @@
+import type { ClientTableHandler } from './types';
+
+export type ClientHandlerCollection<DB> = ClientTableHandler<DB>[];
+
+export function createClientHandlerCollection<DB>(
+  handlers: ClientTableHandler<DB>[]
+): ClientHandlerCollection<DB> {
+  const tables = new Set<string>();
+  for (const handler of handlers) {
+    if (tables.has(handler.table)) {
+      throw new Error(
+        `Client table handler already registered: ${handler.table}`
+      );
+    }
+    tables.add(handler.table);
+  }
+  return handlers;
+}
+
+export function getClientHandler<DB>(
+  handlers: ClientHandlerCollection<DB>,
+  table: string
+): ClientTableHandler<DB> | undefined {
+  return handlers.find((handler) => handler.table === table);
+}
+
+export function getClientHandlerOrThrow<DB>(
+  handlers: ClientHandlerCollection<DB>,
+  table: string
+): ClientTableHandler<DB> {
+  const handler = getClientHandler(handlers, table);
+  if (!handler) {
+    throw new Error(`Missing client table handler for table: ${table}`);
+  }
+  return handler;
+}

package/src/handlers/create-handler.ts

@@ -82,7 +82,7 @@ export interface CreateClientHandlerOptions<
    * Optional column codec resolver.
    * Receives `{ table, column, sqlType?, dialect? }` and returns a codec.
    */
-  columnCodecs?: ColumnCodecSource;
+  codecs?: ColumnCodecSource;
 
   /**
    * Dialect used for codec dialect overrides.
@@ -178,14 +178,14 @@ export function createClientHandler<
   const codecDialect = options.codecDialect ?? 'sqlite';
   const codecCache = new Map<string, ReturnType<typeof toTableColumnCodecs>>();
   const resolveTableCodecs = (row: Record<string, unknown>) => {
-    const columnCodecs = options.columnCodecs;
-    if (!columnCodecs) return {};
+    const codecs = options.codecs;
+    if (!codecs) return {};
     const columns = Object.keys(row);
     if (columns.length === 0) return {};
     const cacheKey = columns.slice().sort().join('\u0000');
     const cached = codecCache.get(cacheKey);
     if (cached) return cached;
-    const resolved = toTableColumnCodecs(table, columnCodecs, columns, {
+    const resolved = toTableColumnCodecs(table, codecs, columns, {
       dialect: codecDialect,
     });
     codecCache.set(cacheKey, resolved);

package/src/index.ts

@@ -9,8 +9,8 @@ export * from './client';
 export * from './conflicts';
 export * from './create-client';
 export * from './engine';
+export * from './handlers/collection';
 export * from './handlers/create-handler';
-export * from './handlers/registry';
 export * from './handlers/types';
 export * from './migrate';
 export * from './mutations';
@@ -22,5 +22,6 @@ export * from './push-engine';
 export * from './query';
 export * from './schema';
 export * from './subscription-state';
+export * from './sync';
 export * from './sync-loop';
 export * from './utils/id';

package/src/migrate.ts

@@ -182,6 +182,13 @@ async function ensureClientSyncSchemaCompat<DB extends SyncClientDb>(
       .addColumn('resolution', 'text')
       .execute();
   });
+
+  await db.schema
+    .createIndex('idx_sync_outbox_commits_status_updated_at')
+    .ifNotExists()
+    .on('sync_outbox_commits')
+    .columns(['status', 'updated_at', 'created_at'])
+    .execute();
 }
 
 /**
@@ -275,6 +282,13 @@ export async function ensureClientSyncSchema<DB extends SyncClientDb>(
     .columns(['status', 'created_at'])
     .execute();
 
+  await db.schema
+    .createIndex('idx_sync_outbox_commits_status_updated_at')
+    .ifNotExists()
+    .on('sync_outbox_commits')
+    .columns(['status', 'updated_at', 'created_at'])
+    .execute();
+
   await db.schema
     .createIndex('idx_sync_conflicts_outbox_commit')
     .ifNotExists()

package/src/mutations.ts

@@ -400,7 +400,7 @@ export interface OutboxCommitConfig<DB extends SyncClientDb> {
   idColumn?: string;
   versionColumn?: string | null;
   omitColumns?: string[];
-  columnCodecs?: ColumnCodecSource;
+  codecs?: ColumnCodecSource;
   codecDialect?: ColumnCodecDialect;
 }
 
@@ -432,8 +432,8 @@ export function createOutboxCommit<DB extends SyncClientDb>(
           table: string,
           row: Record<string, unknown>
         ) => {
-          const columnCodecs = config.columnCodecs;
-          if (!columnCodecs) return {};
+          const codecs = config.codecs;
+          if (!codecs) return {};
           const columns = Object.keys(row);
           if (columns.length === 0) return {};
 
@@ -450,7 +450,7 @@ export function createOutboxCommit<DB extends SyncClientDb>(
           const cached = tableCache.get(cacheKey);
           if (cached) return cached;
 
-          const resolved = toTableColumnCodecs(table, columnCodecs, columns, {
+          const resolved = toTableColumnCodecs(table, codecs, columns, {
             dialect: codecDialect,
           });
           tableCache.set(cacheKey, resolved);

package/src/pull-engine.test.ts

@@ -1,14 +1,15 @@
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
 import { gzipSync } from 'node:zlib';
 import {
+  createDatabase,
   encodeSnapshotRows,
   type SyncPullResponse,
   type SyncTransport,
 } from '@syncular/core';
 import { type Kysely, sql } from 'kysely';
-import { createBunSqliteDb } from '../../dialect-bun-sqlite/src';
+import { createBunSqliteDialect } from '../../dialect-bun-sqlite/src';
+import type { ClientHandlerCollection } from './handlers/collection';
 import { createClientHandler } from './handlers/create-handler';
-import { ClientTableRegistry } from './handlers/registry';
 import { ensureClientSyncSchema } from './migrate';
 import { applyPullResponse, buildPullRequest } from './pull-engine';
 import type { SyncClientDb } from './schema';
@@ -40,7 +41,10 @@ describe('applyPullResponse chunk streaming', () => {
   let db: Kysely<TestDb>;
 
   beforeEach(async () => {
-    db = createBunSqliteDb<TestDb>({ path: ':memory:' });
+    db = createDatabase<TestDb>({
+      dialect: createBunSqliteDialect({ path: ':memory:' }),
+      family: 'sqlite',
+    });
     await ensureClientSyncSchema(db);
     await db.schema
       .createTable('items')
@@ -75,12 +79,12 @@ describe('applyPullResponse chunk streaming', () => {
       },
     };
 
-    const handlers = new ClientTableRegistry<TestDb>().register(
+    const handlers: ClientHandlerCollection<TestDb> = [
       createClientHandler({
         table: 'items',
         scopes: ['items:{id}'],
-      })
-    );
+      }),
+    ];
 
     const options = {
       clientId: 'client-1',

package/src/pull-engine.ts

@@ -6,13 +6,17 @@ import type {
   SyncBootstrapState,
   SyncPullRequest,
   SyncPullResponse,
+  SyncPullSubscriptionResponse,
   SyncSnapshot,
   SyncSubscriptionRequest,
   SyncTransport,
 } from '@syncular/core';
 import { decodeSnapshotRows } from '@syncular/core';
 import { type Kysely, sql, type Transaction } from 'kysely';
-import type { ClientTableRegistry } from './handlers/registry';
+import {
+  type ClientHandlerCollection,
+  getClientHandlerOrThrow,
+} from './handlers/collection';
 import type { ClientTableHandler } from './handlers/types';
 import type {
   SyncClientPlugin,
@@ -513,6 +517,13 @@ export interface SyncPullOnceOptions {
   sha256?: (bytes: Uint8Array) => Promise<string>;
 }
 
+export interface SyncPullRequestState {
+  request: SyncPullRequest;
+  existing: SyncSubscriptionStateTable[];
+  existingById: Map<string, SyncSubscriptionStateTable>;
+  stateId: string;
+}
+
 /**
  * Build a pull request from subscription state. Exported for use
  * by the combined sync path in sync-loop.ts.
@@ -520,12 +531,7 @@ export interface SyncPullOnceOptions {
 export async function buildPullRequest<DB extends SyncClientDb>(
   db: Kysely<DB>,
   options: SyncPullOnceOptions
-): Promise<{
-  request: SyncPullRequest;
-  existing: SyncSubscriptionStateTable[];
-  existingById: Map<string, SyncSubscriptionStateTable>;
-  stateId: string;
-}> {
+): Promise<SyncPullRequestState> {
   const stateId = options.stateId ?? 'default';
 
   const existingResult = await sql<SyncSubscriptionStateTable>`
@@ -566,6 +572,70 @@ export async function buildPullRequest<DB extends SyncClientDb>(
   return { request, existing, existingById, stateId };
 }
 
+export function createFollowupPullState(
+  pullState: SyncPullRequestState,
+  response: SyncPullResponse
+): SyncPullRequestState {
+  const responseById = new Map<string, SyncPullSubscriptionResponse>();
+  for (const sub of response.subscriptions ?? []) {
+    responseById.set(sub.id, sub);
+  }
+
+  const now = Date.now();
+  const nextExisting: SyncSubscriptionStateTable[] = [];
+  const nextExistingById = new Map<string, SyncSubscriptionStateTable>();
+
+  for (const sub of pullState.request.subscriptions ?? []) {
+    const res = responseById.get(sub.id);
+    if (res?.status === 'revoked') {
+      continue;
+    }
+
+    const nextCursor = res ? Math.max(-1, res.nextCursor) : (sub.cursor ?? -1);
+    const nextBootstrapState = res
+      ? res.bootstrap
+        ? (res.bootstrapState ?? null)
+        : null
+      : (sub.bootstrapState ?? null);
+    const prev = pullState.existingById.get(sub.id);
+    const nextRow: SyncSubscriptionStateTable = {
+      state_id: pullState.stateId,
+      subscription_id: sub.id,
+      table: sub.table,
+      scopes_json: serializeJsonCached(sub.scopes ?? {}),
+      params_json: serializeJsonCached(sub.params ?? {}),
+      cursor: nextCursor,
+      bootstrap_state_json: nextBootstrapState
+        ? serializeJsonCached(nextBootstrapState)
+        : null,
+      status: 'active',
+      created_at: prev?.created_at ?? now,
+      updated_at: now,
+    };
+    nextExisting.push(nextRow);
+    nextExistingById.set(nextRow.subscription_id, nextRow);
+  }
+
+  const nextRequest: SyncPullRequest = {
+    ...pullState.request,
+    subscriptions: (pullState.request.subscriptions ?? []).map((sub) => {
+      const row = nextExistingById.get(sub.id);
+      return {
+        ...sub,
+        cursor: Math.max(-1, row?.cursor ?? -1),
+        bootstrapState: parseBootstrapState(row?.bootstrap_state_json),
+      };
+    }),
+  };
+
+  return {
+    request: nextRequest,
+    existing: nextExisting,
+    existingById: nextExistingById,
+    stateId: pullState.stateId,
+  };
+}
+
 /**
  * Apply a pull response (run plugins + write to local DB).
  * Exported for use by the combined sync path in sync-loop.ts.
@@ -573,14 +643,9 @@ export async function buildPullRequest<DB extends SyncClientDb>(
 export async function applyPullResponse<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncPullOnceOptions,
-  pullState: {
-    request: SyncPullRequest;
-    existing: SyncSubscriptionStateTable[];
-    existingById: Map<string, SyncSubscriptionStateTable>;
-    stateId: string;
-  },
+  pullState: SyncPullRequestState,
   rawResponse: SyncPullResponse
 ): Promise<SyncPullResponse> {
   const { request, existing, existingById, stateId } = pullState;
@@ -620,7 +685,10 @@ export async function applyPullResponse<DB extends SyncClientDb>(
               ? JSON.parse(row.scopes_json)
               : row.scopes_json
             : {};
-          await handlers.getOrThrow(row.table).clearAll({ trx, scopes });
+          await getClientHandlerOrThrow(handlers, row.table).clearAll({
+            trx,
+            scopes,
+          });
         } catch {
           // ignore missing table handler
         }
@@ -649,7 +717,10 @@ export async function applyPullResponse<DB extends SyncClientDb>(
                 ? JSON.parse(prev.scopes_json)
                 : prev.scopes_json
               : {};
-            await handlers.getOrThrow(prev.table).clearAll({ trx, scopes });
+            await getClientHandlerOrThrow(handlers, prev.table).clearAll({
+              trx,
+              scopes,
+            });
           } catch {
             // ignore missing handler
           }
@@ -666,7 +737,7 @@ export async function applyPullResponse<DB extends SyncClientDb>(
       // Apply snapshots (bootstrap mode)
       if (sub.bootstrap) {
         for (const snapshot of sub.snapshots ?? []) {
-          const handler = handlers.getOrThrow(snapshot.table);
+          const handler = getClientHandlerOrThrow(handlers, snapshot.table);
           const hasChunkRefs =
             Array.isArray(snapshot.chunks) && snapshot.chunks.length > 0;
 
@@ -698,7 +769,7 @@ export async function applyPullResponse<DB extends SyncClientDb>(
         // Apply incremental changes
         for (const commit of sub.commits) {
           for (const change of commit.changes) {
-            const handler = handlers.getOrThrow(change.table);
+            const handler = getClientHandlerOrThrow(handlers, change.table);
             await handler.applyChange({ trx }, change);
           }
         }
@@ -763,10 +834,11 @@ export async function applyPullResponse<DB extends SyncClientDb>(
 export async function syncPullOnce<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
-  options: SyncPullOnceOptions
+  handlers: ClientHandlerCollection<DB>,
+  options: SyncPullOnceOptions,
+  pullStateOverride?: SyncPullRequestState
 ): Promise<SyncPullResponse> {
-  const pullState = await buildPullRequest(db, options);
+  const pullState = pullStateOverride ?? (await buildPullRequest(db, options));
   const { clientId, ...pullBody } = pullState.request;
   const combined = await transport.sync({ clientId, pull: pullBody });
   if (!combined.pull) {

package/src/push-engine.ts

@@ -7,6 +7,7 @@ import type {
   SyncPushResponse,
   SyncTransport,
 } from '@syncular/core';
+import { countSyncMetric } from '@syncular/core';
 import type { Kysely } from 'kysely';
 import { upsertConflictsForRejectedCommit } from './conflicts';
 import {
@@ -85,6 +86,7 @@ export async function syncPushOnce<DB extends SyncClientDb>(
   }
 
   let res: SyncPushResponse;
+  let usedWsPush = false;
   try {
     // Try WS push first if the transport supports it
     let wsResponse: SyncPushResponse | null = null;
@@ -94,6 +96,7 @@ export async function syncPushOnce<DB extends SyncClientDb>(
 
     if (wsResponse) {
       res = wsResponse;
+      usedWsPush = true;
     } else {
       // Fall back to HTTP
       const combined = await transport.sync({
@@ -156,6 +159,18 @@ export async function syncPushOnce<DB extends SyncClientDb>(
   }
 
   const responseJson = JSON.stringify(responseToUse);
+  const detectedConflicts = responseToUse.results.reduce(
+    (count, result) => count + (result.status === 'conflict' ? 1 : 0),
+    0
+  );
+  if (detectedConflicts > 0 && !usedWsPush) {
+    countSyncMetric('sync.conflicts.detected', detectedConflicts, {
+      attributes: {
+        source: 'client',
+        transport: 'http',
+      },
+    });
+  }
 
   if (responseToUse.status === 'applied' || responseToUse.status === 'cached') {
     await markOutboxCommitAcked(db, {

package/src/sync-loop.ts

@@ -14,7 +14,7 @@ import type {
 } from '@syncular/core';
 import type { Kysely } from 'kysely';
 import { upsertConflictsForRejectedCommit } from './conflicts';
-import type { ClientTableRegistry } from './handlers/registry';
+import type { ClientHandlerCollection } from './handlers/collection';
 import {
   getNextSendableOutboxCommit,
   markOutboxCommitAcked,
@@ -25,7 +25,9 @@ import type { SyncClientPluginContext } from './plugins/types';
 import {
   applyPullResponse,
   buildPullRequest,
+  createFollowupPullState,
   type SyncPullOnceOptions,
+  type SyncPullRequestState,
   syncPullOnce,
 } from './pull-engine';
 import { type SyncPushOnceOptions, syncPushOnce } from './push-engine';
@@ -64,6 +66,8 @@ async function syncPushUntilSettled<DB extends SyncClientDb>(
 interface SyncPullUntilSettledOptions extends SyncPullOnceOptions {
   /** Max pull rounds per call. Default: 20 */
   maxRounds?: number;
+  /** Optional prebuilt state from a prior pull round in the same sync cycle. */
+  initialPullState?: SyncPullRequestState;
 }
 
 interface SyncPullUntilSettledResult {
@@ -119,20 +123,23 @@ function mergePullResponse(
 async function syncPullUntilSettled<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncPullUntilSettledOptions
 ): Promise<SyncPullUntilSettledResult> {
   const maxRounds = Math.max(1, Math.min(1000, options.maxRounds ?? 20));
 
   const aggregatedBySubId = new Map<string, SyncPullSubscriptionResponse>();
+  let pullState =
+    options.initialPullState ?? (await buildPullRequest(db, options));
   let rounds = 0;
 
   for (let i = 0; i < maxRounds; i++) {
     rounds += 1;
-    const res = await syncPullOnce(db, transport, handlers, options);
+    const res = await syncPullOnce(db, transport, handlers, options, pullState);
     mergePullResponse(aggregatedBySubId, res);
 
     if (!needsAnotherPull(res)) break;
+    pullState = createFollowupPullState(pullState, res);
   }
 
   return {
@@ -182,7 +189,7 @@ export interface SyncOnceResult {
 async function syncOnceCombined<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncOnceOptions
 ): Promise<SyncOnceResult> {
   const pullOpts: SyncPullOnceOptions = {
@@ -348,6 +355,7 @@ async function syncOnceCombined<DB extends SyncClientDb>(
       const more = await syncPullUntilSettled(db, transport, handlers, {
         ...pullOpts,
         maxRounds: (options.maxPullRounds ?? 20) - 1,
+        initialPullState: createFollowupPullState(pullState, pullResponse),
       });
       pullRounds += more.rounds;
       mergePullResponse(aggregatedBySubId, more.response);
@@ -364,7 +372,7 @@ async function syncOnceCombined<DB extends SyncClientDb>(
 export async function syncOnce<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncOnceOptions
 ): Promise<SyncOnceResult> {
   return syncOnceCombined(db, transport, handlers, options);