local-lite 0.0.2 → 0.0.4

package/dist/core/sync-worker.js

@@ -7,6 +7,10 @@ const outbox_store_js_1 = require("./outbox-store.js");
 const meta_store_js_1 = require("./meta-store.js");
 const table_manager_js_1 = require("./table-manager.js");
 const logger_js_1 = require("../utils/logger.js");
+/** Maximum outbox records sent per push cycle. */
+const PUSH_BATCH_SIZE = 50;
+/** Maximum incoming delta changes applied in a single database transaction. */
+const DELTA_CHUNK_SIZE = 250;
 class SyncWorker {
     db;
     remote;
@@ -16,20 +20,29 @@ class SyncWorker {
     primaryKey;
     autoSchema;
     schemaManager;
+    syncScope;
     logger;
     retryConfig;
     pushIntervalMs;
     pullIntervalMs;
     maxRetries;
+    autoPauseOnBackground;
+    isPaused = false;
+    lifecycleUnsubscribe;
     pushIntervalTimer;
     pullIntervalTimer;
     pushDebounceTimer;
     networkUnsubscribe;
+    remoteUnsubscribe;
+    subscriptionGeneration = 0;
+    automaticSync;
     isPushing = false;
     isPulling = false;
     lastPulledTimestamp = 0;
     cursorLoaded = false;
     deltaQueue = Promise.resolve();
+    statusRun;
+    statusRerunRequested = false;
     // Telemetry metrics
     totalPushedOperations = 0;
     totalPulledDeltas = 0;
@@ -43,6 +56,7 @@ class SyncWorker {
     lastPullError = null;
     constructor(db, remote, events, options = {}) {
         this.db = db;
+        this.automaticSync = options.autoSync ?? true;
         this.remote = remote;
         this.events = events;
         this.network = options.network ?? new index_js_1.DefaultNetworkStatusProvider();
@@ -52,19 +66,9 @@ class SyncWorker {
         this.schemaManager = options.schemaManager;
         this.pushIntervalMs = options.pushIntervalMs ?? 5000;
         this.pullIntervalMs = options.pullIntervalMs ?? 10000;
-        // Configure logger
-        if (options.logger instanceof logger_js_1.SyncLogger) {
-            this.logger = options.logger;
-        }
-        else if (typeof options.logger === 'boolean') {
-            this.logger = new logger_js_1.SyncLogger({ enabled: options.logger, level: options.logLevel });
-        }
-        else if (options.logger && typeof options.logger === 'object') {
-            this.logger = new logger_js_1.SyncLogger({ customLogger: options.logger, level: options.logLevel });
-        }
-        else {
-            this.logger = options.logLevel ? new logger_js_1.SyncLogger({ level: options.logLevel }) : logger_js_1.defaultLogger;
-        }
+        this.syncScope = options.syncScope;
+        this.autoPauseOnBackground = options.autoPauseOnBackground ?? true;
+        this.logger = (0, logger_js_1.createSyncLogger)(options.logger, options.logLevel);
         // Configure retries & backoff
         const r = options.retry;
         if (typeof r === 'number') {
@@ -102,23 +106,41 @@ class SyncWorker {
      */
     start() {
         this.stop();
+        this.automaticSync = true;
+        this.isPaused = false;
+        const generation = this.subscriptionGeneration;
+        this.setupLifecycleListener();
+        // If currently backgrounded, pause immediately and wait for foreground
+        if (this.isAppBackgrounded()) {
+            this.isPaused = true;
+            this.logger.info('App currently in background: sync worker paused until foreground');
+            this.emitStatus();
+            return;
+        }
         this.pushIntervalTimer = setInterval(() => this.pushLocalChanges(), this.pushIntervalMs);
         this.pullIntervalTimer = setInterval(() => this.pullRemoteChanges(), this.pullIntervalMs);
         // Subscribe to live remote changes
-        this.remote.subscribeToLiveChanges((deltas) => {
-            this.applyDeltasLocally(deltas).catch((err) => {
+        const unsubscribe = this.remote.subscribeToLiveChanges((deltas) => {
+            if (generation !== this.subscriptionGeneration || this.isPaused)
+                return;
+            // A realtime event is not a complete pull page and cannot advance its checkpoint.
+            this.applyDeltasLocally(deltas, { advanceCursor: false }).catch((err) => {
                 this.logger.error('Error applying live remote deltas:', err);
             });
         });
-        // Subscribe to network connectivity changes
+        if (typeof unsubscribe === 'function')
+            this.remoteUnsubscribe = unsubscribe;
+        // Subscribe to network connectivity changes (only pull on actual offline -> online transition)
+        let lastNetworkOnline = undefined;
         this.networkUnsubscribe = this.network.subscribe((online) => {
             this.emitStatus();
-            if (online) {
+            if (online && lastNetworkOnline === false && !this.isPaused) {
                 this.schedulePush(0);
                 this.pullRemoteChanges().catch((err) => {
                     this.logger.error('Error pulling changes on reconnect:', err);
                 });
             }
+            lastNetworkOnline = online;
         });
         // Initial pull
         this.pullRemoteChanges().catch((err) => {
@@ -130,6 +152,17 @@ class SyncWorker {
      * Stops all active intervals, timers, and listeners.
      */
     stop() {
+        this.automaticSync = false;
+        this.isPaused = false;
+        this.subscriptionGeneration++;
+        if (this.lifecycleUnsubscribe) {
+            this.lifecycleUnsubscribe();
+            this.lifecycleUnsubscribe = undefined;
+        }
+        if (this.remoteUnsubscribe) {
+            this.remoteUnsubscribe();
+            this.remoteUnsubscribe = undefined;
+        }
         if (this.pushIntervalTimer) {
             clearInterval(this.pushIntervalTimer);
             this.pushIntervalTimer = undefined;
@@ -147,10 +180,123 @@ class SyncWorker {
             this.networkUnsubscribe = undefined;
         }
     }
+    /**
+     * Pauses recurring interval timers and active sync loops to conserve battery and data.
+     */
+    pause() {
+        if (this.isPaused)
+            return;
+        this.isPaused = true;
+        this.logger.info('App backgrounded: pausing sync timers');
+        if (this.pushIntervalTimer) {
+            clearInterval(this.pushIntervalTimer);
+            this.pushIntervalTimer = undefined;
+        }
+        if (this.pullIntervalTimer) {
+            clearInterval(this.pullIntervalTimer);
+            this.pullIntervalTimer = undefined;
+        }
+        if (this.pushDebounceTimer) {
+            clearTimeout(this.pushDebounceTimer);
+            this.pushDebounceTimer = undefined;
+        }
+        this.emitStatus();
+    }
+    /**
+     * Resumes recurring interval timers and triggers an immediate catch-up push and pull.
+     */
+    resume() {
+        if (!this.isPaused)
+            return;
+        this.isPaused = false;
+        this.logger.info('App foregrounded: resuming sync');
+        if (this.automaticSync) {
+            if (!this.pushIntervalTimer) {
+                this.pushIntervalTimer = setInterval(() => this.pushLocalChanges(), this.pushIntervalMs);
+            }
+            if (!this.pullIntervalTimer) {
+                this.pullIntervalTimer = setInterval(() => this.pullRemoteChanges(), this.pullIntervalMs);
+            }
+            this.schedulePush(0);
+            this.pullRemoteChanges().catch((err) => {
+                this.logger.error('Error pulling changes on app resume:', err);
+            });
+        }
+        this.emitStatus();
+    }
+    /**
+     * Returns whether the sync worker is currently suspended due to app backgrounding.
+     */
+    get isBackgroundPaused() {
+        return this.isPaused;
+    }
+    isAppBackgrounded() {
+        if (!this.autoPauseOnBackground)
+            return false;
+        // React Native AppState
+        try {
+            const { AppState } = require('react-native');
+            if (AppState?.currentState && typeof AppState.currentState === 'string') {
+                return Boolean(AppState.currentState.match(/inactive|background/));
+            }
+        }
+        catch {
+            // Not React Native
+        }
+        // Web Page Visibility API
+        if (typeof document !== 'undefined' && typeof document.hidden === 'boolean') {
+            return document.hidden;
+        }
+        return false;
+    }
+    setupLifecycleListener() {
+        if (!this.autoPauseOnBackground || this.lifecycleUnsubscribe)
+            return;
+        // 1. Try React Native AppState
+        try {
+            const { AppState } = require('react-native');
+            if (AppState && typeof AppState.addEventListener === 'function') {
+                const sub = AppState.addEventListener('change', (state) => {
+                    if (state.match(/inactive|background/)) {
+                        this.pause();
+                    }
+                    else if (state === 'active') {
+                        this.resume();
+                    }
+                });
+                this.lifecycleUnsubscribe = () => {
+                    if (typeof sub?.remove === 'function') {
+                        sub.remove();
+                    }
+                };
+                return;
+            }
+        }
+        catch {
+            // Not React Native
+        }
+        // 2. Web Page Visibility API
+        if (typeof document !== 'undefined' && typeof document.addEventListener === 'function') {
+            const onVisibilityChange = () => {
+                if (document.hidden) {
+                    this.pause();
+                }
+                else {
+                    this.resume();
+                }
+            };
+            document.addEventListener('visibilitychange', onVisibilityChange);
+            this.lifecycleUnsubscribe = () => {
+                document.removeEventListener('visibilitychange', onVisibilityChange);
+            };
+        }
+    }
     /**
      * Schedules an immediate push with a short debounce.
      */
     schedulePush(delayMs = 50) {
+        if (!this.automaticSync || this.isPaused)
+            return;
         if (this.pushDebounceTimer) {
             clearTimeout(this.pushDebounceTimer);
         }
@@ -161,6 +307,12 @@ class SyncWorker {
             });
         }, delayMs);
     }
+    /**
+     * Dynamically sets or updates the active sync scope (e.g. switching active businessId or userId).
+     */
+    setSyncScope(scope) {
+        this.syncScope = scope;
+    }
     async isOnline() {
         try {
             return await Promise.resolve(this.network.isOnline());
@@ -169,41 +321,70 @@ class SyncWorker {
             return true;
         }
     }
-    async emitStatus() {
-        try {
-            const online = await this.isOnline();
-            const counts = await outbox_store_js_1.OutboxStore.getCounts(this.db);
-            const statusEvent = {
-                isOnline: online,
-                isPushing: this.isPushing,
-                isPulling: this.isPulling,
-                pendingCount: counts.pending,
-            };
-            this.events.emit('sync:status', statusEvent);
-        }
-        catch {
-            // Ignored
+    /**
+     * Emits a `sync:status` snapshot. Calls are coalesced: while one snapshot is being
+     * computed, further requests collapse into a single trailing run that reflects the
+     * latest state, so bursts of push/pull transitions cost at most two COUNT queries.
+     */
+    emitStatus() {
+        if (this.statusRun) {
+            this.statusRerunRequested = true;
+            return this.statusRun;
         }
+        const run = async () => {
+            do {
+                this.statusRerunRequested = false;
+                try {
+                    const online = await this.isOnline();
+                    const counts = await outbox_store_js_1.OutboxStore.getCounts(this.db);
+                    const statusEvent = {
+                        isOnline: online,
+                        isPushing: this.isPushing,
+                        isPulling: this.isPulling,
+                        pendingCount: counts.total,
+                    };
+                    this.events.emit('sync:status', statusEvent);
+                }
+                catch {
+                    // Ignored
+                }
+            } while (this.statusRerunRequested);
+        };
+        this.statusRun = run().finally(() => {
+            this.statusRun = undefined;
+        });
+        return this.statusRun;
     }
     /**
      * Pushes pending outbox records to the remote database.
      */
     async pushLocalChanges() {
-        if (this.isPushing)
-            return;
-        if (!(await this.isOnline()))
+        if (this.isPushing || this.isPaused)
             return;
         this.isPushing = true;
         this.emitStatus();
         const startTime = Date.now();
         let pendingRecords = [];
         try {
+            if (!(await this.isOnline()))
+                return;
             this.totalPushCycles++;
-            pendingRecords = await outbox_store_js_1.OutboxStore.getPending(this.db, this.maxRetries);
+            // No push is active: recover records left behind by a failed status write.
+            await outbox_store_js_1.OutboxStore.resetStaleProcessing(this.db);
+            pendingRecords = await outbox_store_js_1.OutboxStore.getPending(this.db, this.maxRetries, PUSH_BATCH_SIZE);
             if (pendingRecords.length === 0) {
                 return;
             }
-            const operations = pendingRecords.map((r) => ({
+            // Filter out internal/ephemeral tables (e.g. starting with '_') so they are never sent to remote backends
+            const internalRecords = pendingRecords.filter((r) => r.tableName.startsWith('_'));
+            if (internalRecords.length > 0) {
+                await outbox_store_js_1.OutboxStore.deleteCompleted(this.db, internalRecords.map((r) => r.id)).catch(() => { });
+            }
+            const validRecords = pendingRecords.filter((r) => !r.tableName.startsWith('_'));
+            if (validRecords.length === 0) {
+                return;
+            }
+            const operations = validRecords.map((r) => ({
                 id: r.id,
                 tableName: r.tableName,
                 rowId: r.rowId,
@@ -214,35 +395,65 @@ class SyncWorker {
             const recordIds = operations.map((o) => o.id);
             // Mark records as PROCESSING
             await outbox_store_js_1.OutboxStore.markProcessing(this.db, recordIds);
-            const success = await this.remote.pushChanges(operations);
+            const pushRes = await this.remote.pushChanges(operations);
             const durationMs = Date.now() - startTime;
             this.lastPushDurationMs = durationMs;
             this.lastPushTimestamp = Date.now();
-            if (success) {
-                // Successful push: delete rows from outbox
-                await outbox_store_js_1.OutboxStore.deleteCompleted(this.db, recordIds);
-                this.totalPushedOperations += operations.length;
+            let isSuccess = false;
+            let successfulIds = [];
+            let failedIds = [];
+            let errorsMap = {};
+            if (typeof pushRes === 'boolean') {
+                isSuccess = pushRes;
+                if (pushRes) {
+                    successfulIds = recordIds;
+                }
+                else {
+                    failedIds = recordIds;
+                }
+            }
+            else if (pushRes && typeof pushRes === 'object') {
+                isSuccess = Boolean(pushRes.success);
+                successfulIds = pushRes.successfulIds ?? (isSuccess ? recordIds : []);
+                failedIds = pushRes.failedIds ?? (isSuccess ? [] : recordIds.filter((id) => !successfulIds.includes(id)));
+                errorsMap = pushRes.errors ?? {};
+            }
+            if (successfulIds.length > 0) {
+                // Delete records that were pushed successfully
+                await outbox_store_js_1.OutboxStore.deleteCompleted(this.db, successfulIds);
+                this.totalPushedOperations += successfulIds.length;
+                this.events.emit('sync_outbox', { operation: 'DELETE', rowId: 'batch' });
+            }
+            if (failedIds.length === 0) {
                 this.lastPushError = null;
                 const pushEvent = {
                     success: true,
-                    count: operations.length,
+                    count: successfulIds.length,
                     durationMs,
                     error: null,
                 };
                 this.events.emit('sync:push', pushEvent);
-                this.events.emit('sync_outbox', { operation: 'DELETE', rowId: 'batch' });
+                // Drain backlog: if a full batch was processed and all succeeded, continue immediately
+                if (operations.length >= PUSH_BATCH_SIZE) {
+                    this.schedulePush(0);
+                }
             }
             else {
-                const errMsg = 'Remote push returned false';
+                const errMsg = Object.values(errorsMap)[0] || 'Remote push returned failure';
                 this.lastPushError = errMsg;
                 const pushEvent = {
                     success: false,
-                    count: operations.length,
+                    count: failedIds.length,
                     durationMs,
                     error: errMsg,
                 };
                 this.events.emit('sync:push', pushEvent);
-                await this.handlePushFailure(pendingRecords, errMsg);
+                const failedRecords = pendingRecords.filter((r) => failedIds.includes(r.id));
+                await this.handlePushFailure(failedRecords, errMsg, undefined, errorsMap);
+                // If part of the batch succeeded, keep draining the rest
+                if (successfulIds.length > 0 && operations.length >= PUSH_BATCH_SIZE) {
+                    this.schedulePush(0);
+                }
             }
         }
         catch (error) {
@@ -268,10 +479,18 @@ class SyncWorker {
             this.emitStatus();
         }
     }
-    async handlePushFailure(records, errorMessage, errorObj) {
+    async handlePushFailure(records, errorMessage, errorObj, errorsByRecordId) {
         try {
-            const recordIds = records.map((r) => r.id);
-            await outbox_store_js_1.OutboxStore.markFailed(this.db, recordIds, errorMessage);
+            if (errorsByRecordId && Object.keys(errorsByRecordId).length > 0) {
+                for (const rec of records) {
+                    const msg = errorsByRecordId[rec.id] || errorMessage;
+                    await outbox_store_js_1.OutboxStore.markFailed(this.db, [rec.id], msg);
+                }
+            }
+            else {
+                const recordIds = records.map((r) => r.id);
+                await outbox_store_js_1.OutboxStore.markFailed(this.db, recordIds, errorMessage);
+            }
             this.events.emit('sync_outbox', { operation: 'UPDATE', rowId: 'batch' });
             // If custom shouldRetry filter specifies an operation should NOT be retried, mark it FAILED permanently
             if (this.retryConfig.shouldRetry && errorObj) {
@@ -303,20 +522,23 @@ class SyncWorker {
      * Pulls delta changes from the remote backend since lastPulledTimestamp.
      */
     async pullRemoteChanges() {
-        if (this.isPulling)
-            return;
-        if (!(await this.isOnline()))
+        if (this.isPulling || this.isPaused)
             return;
         this.isPulling = true;
         this.emitStatus();
         const startTime = Date.now();
         try {
+            if (!(await this.isOnline()))
+                return;
             this.totalPullCycles++;
             if (!this.cursorLoaded) {
                 this.lastPulledTimestamp = await meta_store_js_1.MetaStore.getLastSyncedAt(this.db);
                 this.cursorLoaded = true;
             }
-            const deltas = await this.remote.fetchChanges(this.lastPulledTimestamp);
+            const scope = typeof this.syncScope === 'function' ? await this.syncScope() : this.syncScope;
+            const deltas = scope !== undefined
+                ? await this.remote.fetchChanges(this.lastPulledTimestamp, scope)
+                : await this.remote.fetchChanges(this.lastPulledTimestamp);
             const durationMs = Date.now() - startTime;
             this.lastPullDurationMs = durationMs;
             this.lastPullTimestamp = Date.now();
@@ -325,6 +547,10 @@ class SyncWorker {
             if (deltas) {
                 this.totalPulledDeltas += changesCount;
                 await this.applyDeltasLocally(deltas);
+                if (deltas.timestamp && deltas.timestamp > this.lastPulledTimestamp) {
+                    this.lastPulledTimestamp = deltas.timestamp;
+                    await meta_store_js_1.MetaStore.setLastSyncedAt(this.db, deltas.timestamp);
+                }
             }
             const pullEvent = {
                 success: true,
@@ -360,9 +586,10 @@ class SyncWorker {
      * Applies incoming server delta changes to local tables with conflict resolution.
      * Serializes execution in a queue to prevent concurrent SQLite transactions.
      */
-    async applyDeltasLocally(deltas) {
+    async applyDeltasLocally(deltas, options = {}) {
         const task = async () => {
-            await this.processDeltasLocally(deltas);
+            await this.getLastPulledTimestamp();
+            await this.processDeltasLocally(options.advanceCursor === false ? { ...deltas, timestamp: 0 } : deltas);
         };
         const next = this.deltaQueue.then(task, task);
         this.deltaQueue = next.catch(() => { });
@@ -371,63 +598,83 @@ class SyncWorker {
     async processDeltasLocally(deltas) {
         if (!deltas.changes || deltas.changes.length === 0) {
             if (deltas.timestamp && deltas.timestamp > this.lastPulledTimestamp) {
+                await meta_store_js_1.MetaStore.setLastSyncedAt(this.db, deltas.timestamp);
                 this.lastPulledTimestamp = deltas.timestamp;
-                await meta_store_js_1.MetaStore.setLastSyncedAt(this.db, this.lastPulledTimestamp);
             }
             return;
         }
-        await this.db.transaction(async (tx) => {
-            for (const change of deltas.changes) {
-                // 1. Check for pending local mutations for this (table_name, row_id)
-                const localPendingRecord = await outbox_store_js_1.OutboxStore.findPendingByRow(tx, change.tableName, change.rowId);
-                // 2. Query current local row if it exists
-                const localRow = await table_manager_js_1.TableManager.fetchRow(tx, change.tableName, change.rowId, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
-                // 3. Conflict resolution if there is a pending local change
-                if (localPendingRecord) {
-                    const resolution = await Promise.resolve(this.conflictResolver({
-                        tableName: change.tableName,
-                        rowId: change.rowId,
-                        remoteChange: change,
-                        localOutboxRecord: localPendingRecord,
-                        localRow,
-                    }));
-                    const resolutionStr = typeof resolution === 'string' ? resolution : 'merge';
-                    const conflictEvent = {
-                        tableName: change.tableName,
-                        rowId: change.rowId,
-                        resolution: resolutionStr,
-                        timestamp: Date.now(),
-                    };
-                    this.events.emit('sync:conflict', conflictEvent);
-                    if (resolution === 'keep-local') {
-                        // Local offline change takes precedence
-                        continue;
-                    }
-                    if (resolution === 'apply-remote') {
-                        // Remote change wins: remove the superseded local pending outbox mutation
-                        await outbox_store_js_1.OutboxStore.deleteRecord(tx, localPendingRecord.id);
-                    }
-                    else if (typeof resolution === 'object' && resolution.mergePayload) {
-                        // Merge scenario
-                        change.payload = resolution.mergePayload;
-                        await outbox_store_js_1.OutboxStore.updatePayload(tx, localPendingRecord.id, resolution.mergePayload);
+        const totalChanges = deltas.changes.length;
+        // Apply incoming deltas in chunks to avoid holding long SQLite write locks
+        // and starving concurrent UI reads on mobile/embedded environments.
+        for (let i = 0; i < totalChanges; i += DELTA_CHUNK_SIZE) {
+            const chunk = deltas.changes.slice(i, i + DELTA_CHUNK_SIZE);
+            const isLastChunk = i + DELTA_CHUNK_SIZE >= totalChanges;
+            const queuedEvents = [];
+            await this.db.transaction(async (tx) => {
+                for (const change of chunk) {
+                    // 1. Check for pending local mutations for this (table_name, row_id)
+                    const localPendingRecord = await outbox_store_js_1.OutboxStore.findPendingByRow(tx, change.tableName, change.rowId);
+                    // 2. Conflict resolution if there is a pending local change
+                    if (localPendingRecord) {
+                        // Only load the current local row when a resolver actually needs it.
+                        const localRow = await table_manager_js_1.TableManager.fetchRow(tx, change.tableName, change.rowId, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
+                        const resolution = await Promise.resolve(this.conflictResolver({
+                            tableName: change.tableName,
+                            rowId: change.rowId,
+                            remoteChange: change,
+                            localOutboxRecord: localPendingRecord,
+                            localRow,
+                        }));
+                        const resolutionStr = typeof resolution === 'string' ? resolution : 'merge';
+                        const conflictEvent = {
+                            tableName: change.tableName,
+                            rowId: change.rowId,
+                            resolution: resolutionStr,
+                            timestamp: Date.now(),
+                        };
+                        queuedEvents.push({ event: 'sync:conflict', data: conflictEvent });
+                        if (resolution === 'keep-local') {
+                            // Local offline change takes precedence
+                            continue;
+                        }
+                        if (resolution === 'apply-remote') {
+                            // Remote change wins: remove the superseded local pending outbox mutation
+                            await outbox_store_js_1.OutboxStore.deleteRecord(tx, localPendingRecord.id);
+                        }
+                        else if (typeof resolution === 'object' && resolution.mergePayload) {
+                            // Merge scenario
+                            change.payload = resolution.mergePayload;
+                            await outbox_store_js_1.OutboxStore.updatePayload(tx, localPendingRecord.id, resolution.mergePayload);
+                        }
                     }
+                    // 3. Apply remote change to local database
+                    await table_manager_js_1.TableManager.applyMutation(tx, change.tableName, change.rowId, change.operation, change.payload, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
+                    // 4. Queue table change event to notify reactive listeners after commit
+                    queuedEvents.push({
+                        event: change.tableName,
+                        data: {
+                            operation: change.operation,
+                            rowId: change.rowId,
+                            payload: change.payload,
+                            source: 'remote',
+                        },
+                    });
                 }
-                // 4. Apply remote change to local database
-                await table_manager_js_1.TableManager.applyMutation(tx, change.tableName, change.rowId, change.operation, change.payload, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
-                // 5. Emit table change event to notify reactive listeners
-                this.events.emit(change.tableName, {
-                    operation: change.operation,
-                    rowId: change.rowId,
-                    payload: change.payload,
-                    source: 'remote',
-                });
+                // Advance durable checkpoint only when a valid pull timestamp was provided
+                if (isLastChunk && deltas.timestamp && deltas.timestamp > this.lastPulledTimestamp) {
+                    await meta_store_js_1.MetaStore.setLastSyncedAt(tx, deltas.timestamp);
+                    this.lastPulledTimestamp = deltas.timestamp;
+                }
+            });
+            // Emit events after chunk commit
+            for (const item of queuedEvents) {
+                this.events.emit(item.event, item.data);
             }
-            // Persist sync cursor atomically within the same transaction as delta writes
-            if (deltas.timestamp && deltas.timestamp > this.lastPulledTimestamp) {
-                await meta_store_js_1.MetaStore.setLastSyncedAt(tx, deltas.timestamp);
+            // Yield between chunks if there are multiple chunks
+            if (totalChanges > DELTA_CHUNK_SIZE && !isLastChunk) {
+                await new Promise((resolve) => setTimeout(resolve, 0));
             }
-        });
+        }
         if (deltas.timestamp) {
             this.lastPulledTimestamp = Math.max(this.lastPulledTimestamp, deltas.timestamp);
         }