@statezero/core 0.1.2 → 0.1.3-9.2

package/dist/syncEngine/stores/modelStore.js

@@ -1,12 +1,30 @@
 import { Operation, Status, Type, operationRegistry } from './operation.js';
-import { isNil, isEmpty, trim } from 'lodash-es';
+import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { modelEventEmitter } from './reactivity.js';
 import { Cache } from '../cache/cache.js';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
-const emitEvents = (modelClass, events) => {
-    // helper method to emit every event
-    events.forEach(event => {
-        modelEventEmitter.emit(`${modelClass.configKey}::${modelClass.modelName}::render`, event);
+const emitEvents = (store, events) => {
+    if (!Array.isArray(events))
+        return;
+    events.forEach((event) => {
+        const pk = event.pk;
+        if (isNil(pk))
+            return;
+        const newRenderedDataArray = store.render([pk], true);
+        const newRenderedData = newRenderedDataArray.length > 0 ? newRenderedDataArray[0] : null;
+        const lastRenderedData = store._lastRenderedData.get(pk);
+        if (!isEqual(newRenderedData, lastRenderedData)) {
+            store._lastRenderedData.set(pk, newRenderedData);
+            modelEventEmitter.emit(`${store.modelClass.configKey}::${store.modelClass.modelName}::render`, event);
+            store.renderCallbacks.forEach((callback) => {
+                try {
+                    callback();
+                }
+                catch (error) {
+                    console.warn("Error in model store render callback:", error);
+                }
+            });
+        }
     });
 };
 class EventData {
@@ -61,14 +79,20 @@ export class ModelStore {
         if (initialOperations && initialOperations.length > 0) {
             this._loadOperations(initialOperations);
         }
-        this.modelCache = new Cache('model-cache', {}, this.onHydrated.bind(this));
+        this.modelCache = new Cache("model-cache", {}, this.onHydrated.bind(this));
+        this._lastRenderedData = new Map();
+        this.renderCallbacks = new Set();
+    }
+    registerRenderCallback(callback) {
+        this.renderCallbacks.add(callback);
+        return () => this.renderCallbacks.delete(callback);
     }
     /**
      * Load operations from data and add them to the operations map,
      * reusing existing operations from the registry if they exist
      */
     _loadOperations(operationsData) {
-        operationsData.forEach(opData => {
+        operationsData.forEach((opData) => {
             const existingOp = operationRegistry.get(opData.operationId);
             if (existingOp) {
                 // If the operation exists in the registry, use it
@@ -98,7 +122,7 @@ export class ModelStore {
         let nonTempPkItems = [];
         result.forEach((item) => {
             let pk = item[pkField];
-            if (typeof pk === 'string' && containsTempPk(pk)) {
+            if (typeof pk === "string" && containsTempPk(pk)) {
                 pk = replaceTempPks(item[pkField]);
                 if (isNil(pk) || isEmpty(trim(pk))) {
                     return;
@@ -117,7 +141,7 @@ export class ModelStore {
         let nonTempPkItems = [];
         items.forEach((item) => {
             let pk = item[pkField];
-            if (typeof pk === 'string' && containsTempPk(pk)) {
+            if (typeof pk === "string" && containsTempPk(pk)) {
                 pk = replaceTempPks(item[pkField]);
                 if (isNil(pk) || isEmpty(trim(pk))) {
                     return;
@@ -134,16 +158,16 @@ export class ModelStore {
         // Otherwise, we're rendering specific items - update only those items
         const currentCache = this.modelCache.get(this.cacheKey) || [];
         // Filter out items that were requested but not in the result (they were deleted)
-        const filteredCache = currentCache.filter(item => item &&
-            typeof item === 'object' &&
+        const filteredCache = currentCache.filter((item) => item &&
+            typeof item === "object" &&
             pkField in item &&
             (!requestedPks.has(item[pkField]) ||
-                nonTempPkItems.some(newItem => newItem[pkField] === item[pkField])));
+                nonTempPkItems.some((newItem) => newItem[pkField] === item[pkField])));
         // Create a map for faster lookups
-        const cacheMap = new Map(filteredCache.map(item => [item[pkField], item]));
+        const cacheMap = new Map(filteredCache.map((item) => [item[pkField], item]));
         // Add or update items from the result
         for (const item of nonTempPkItems) {
-            if (item && typeof item === 'object' && pkField in item) {
+            if (item && typeof item === "object" && pkField in item) {
                 cacheMap.set(item[pkField], item);
             }
         }
@@ -164,35 +188,35 @@ export class ModelStore {
         if (this.operationsMap.size > this.pruneThreshold) {
             this.prune();
         }
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     updateOperation(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return false;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
         return true;
     }
     confirm(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     reject(operation) {
         if (!this.operationsMap.has(operation.operationId))
             return;
         this.operationsMap.set(operation.operationId, operation);
-        emitEvents(this.modelClass, EventData.fromOperation(operation));
+        emitEvents(this, EventData.fromOperation(operation));
     }
     setOperations(operations = []) {
         const prevOps = this.operations;
         this.operationsMap.clear();
-        operations.forEach(op => {
+        operations.forEach((op) => {
             this.operationsMap.set(op.operationId, op);
         });
         const allOps = [...prevOps, ...this.operations];
-        emitEvents(this.modelClass, EventData.fromOperations(allOps));
+        emitEvents(this, EventData.fromOperations(allOps));
     }
     // Ground truth data methods
     setGroundTruth(groundTruth) {
@@ -200,7 +224,7 @@ export class ModelStore {
         this.groundTruthArray = Array.isArray(groundTruth) ? groundTruth : [];
         // reactivity - gather all ops
         const allOps = [...prevGroundTruth, ...this.groundTruthArray];
-        emitEvents(this.modelClass, EventData.fromInstances(allOps, this.modelClass));
+        emitEvents(this, EventData.fromInstances(allOps, this.modelClass));
     }
     getGroundTruth() {
         return this.groundTruthArray;
@@ -208,16 +232,16 @@ export class ModelStore {
     get groundTruthPks() {
         const pk = this.pkField;
         return this.groundTruthArray
-            .filter(instance => instance && typeof instance === 'object' && pk in instance)
-            .map(instance => instance[pk]);
+            .filter((instance) => instance && typeof instance === "object" && pk in instance)
+            .map((instance) => instance[pk]);
     }
     addToGroundTruth(instances) {
         if (!Array.isArray(instances) || instances.length === 0)
             return;
         const pkField = this.pkField;
         const pkMap = new Map();
-        instances.forEach(inst => {
-            if (inst && typeof inst === 'object' && pkField in inst) {
+        instances.forEach((inst) => {
+            if (inst && typeof inst === "object" && pkField in inst) {
                 pkMap.set(inst[pkField], inst);
             }
             else {
@@ -230,7 +254,9 @@ export class ModelStore {
         const processedPks = new Set();
         const checkpointInstances = []; // Track instances that need CHECKPOINT operations
         for (const existingItem of this.groundTruthArray) {
-            if (!existingItem || typeof existingItem !== 'object' || !(pkField in existingItem)) {
+            if (!existingItem ||
+                typeof existingItem !== "object" ||
+                !(pkField in existingItem)) {
                 continue;
             }
             const pk = existingItem[pkField];
@@ -252,18 +278,20 @@ export class ModelStore {
         // Create CHECKPOINT operation for instances that already existed
         if (checkpointInstances.length > 0) {
             const checkpointOperation = new Operation({
-                operationId: `checkpoint_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                operationId: `checkpoint_${Date.now()}_${Math.random()
+                    .toString(36)
+                    .substr(2, 9)}`,
                 type: Type.CHECKPOINT,
                 instances: checkpointInstances,
                 status: Status.CONFIRMED,
                 timestamp: Date.now(),
-                queryset: this.modelClass.objects.all()
+                queryset: this.modelClass.objects.all(),
             });
             this.operationsMap.set(checkpointOperation.operationId, checkpointOperation);
             console.log(`[ModelStore ${this.modelClass.modelName}] Created CHECKPOINT operation for ${checkpointInstances.length} existing instances`);
         }
         // reactivity - use all the newly added instances (both new and updated)
-        emitEvents(this.modelClass, EventData.fromInstances([...checkpointInstances, ...Array.from(pkMap.values())], this.modelClass));
+        emitEvents(this, EventData.fromInstances([...checkpointInstances, ...Array.from(pkMap.values())], this.modelClass));
     }
     _filteredOperations(pks, operations) {
         if (!pks)
@@ -271,7 +299,7 @@ export class ModelStore {
         const pkField = this.pkField;
         let filteredOps = [];
         for (const op of operations) {
-            let relevantInstances = op.instances.filter(instance => pks.has(instance[pkField] || instance));
+            let relevantInstances = op.instances.filter((instance) => pks.has(instance[pkField] || instance));
             if (relevantInstances.length > 0) {
                 filteredOps.push({
                     operationId: op.operationId,
@@ -280,7 +308,7 @@ export class ModelStore {
                     queryset: op.queryset,
                     type: op.type,
                     status: op.status,
-                    args: op.args
+                    args: op.args,
                 });
             }
         }
@@ -290,7 +318,7 @@ export class ModelStore {
         const pkField = this.pkField;
         let groundTruthMap = new Map();
         for (const instance of groundTruthArray) {
-            if (!instance || typeof instance !== 'object' || !(pkField in instance)) {
+            if (!instance || typeof instance !== "object" || !(pkField in instance)) {
                 continue;
             }
             const pk = instance[pkField];
@@ -303,7 +331,7 @@ export class ModelStore {
     applyOperation(operation, currentInstances) {
         const pkField = this.pkField;
         for (const instance of operation.instances) {
-            if (!instance || typeof instance !== 'object' || !(pkField in instance)) {
+            if (!instance || typeof instance !== "object" || !(pkField in instance)) {
                 console.warn(`[ModelStore ${this.modelClass.modelName}] Skipping instance ${instance} in operation ${operation.operationId} during applyOperation due to missing PK field '${String(pkField)}' or invalid format.`);
                 continue;
             }
@@ -322,9 +350,9 @@ export class ModelStore {
                         currentInstances.set(pk, { ...existing, ...instance });
                     }
                     else {
-                        const wasDeletedLocally = this.operations.some(op => op.type === Type.DELETE &&
+                        const wasDeletedLocally = this.operations.some((op) => op.type === Type.DELETE &&
                             op.status !== Status.REJECTED &&
-                            op.instances.some(inst => inst && inst[pkField] === pk));
+                            op.instances.some((inst) => inst && inst[pkField] === pk));
                         if (!wasDeletedLocally) {
                             currentInstances.set(pk, instance);
                         }
@@ -343,10 +371,10 @@ export class ModelStore {
     }
     getTrimmedOperations() {
         const twoMinutesAgo = Date.now() - 1000 * 60 * 2;
-        return this.operations.filter(operation => operation.timestamp > twoMinutesAgo);
+        return this.operations.filter((operation) => operation.timestamp > twoMinutesAgo);
     }
     getInflightOperations() {
-        return this.operations.filter(operation => operation.status != Status.CONFIRMED &&
+        return this.operations.filter((operation) => operation.status != Status.CONFIRMED &&
             operation.status != Status.REJECTED);
     }
     // Pruning
@@ -358,12 +386,16 @@ export class ModelStore {
     }
     // Render methods
     render(pks = null, optimistic = true) {
-        const pksSet = pks === null ? null :
-            (pks instanceof Set ? pks : new Set(Array.isArray(pks) ? pks : [pks]));
+        const pksSet = pks === null
+            ? null
+            : pks instanceof Set
+                ? pks
+                : new Set(Array.isArray(pks) ? pks : [pks]);
         const renderedInstancesMap = this._filteredGroundTruth(pksSet, this.groundTruthArray);
         const relevantOperations = this._filteredOperations(pksSet, this.operations);
         for (const op of relevantOperations) {
-            if (op.status !== Status.REJECTED && (optimistic || op.status === Status.CONFIRMED)) {
+            if (op.status !== Status.REJECTED &&
+                (optimistic || op.status === Status.CONFIRMED)) {
                 this.applyOperation(op, renderedInstancesMap);
             }
         }
@@ -386,7 +418,10 @@ export class ModelStore {
                 this.setOperations(trimmedOps);
                 return;
             }
-            const newGroundTruth = await this.fetchFn({ pks: currentPks, modelClass: this.modelClass });
+            const newGroundTruth = await this.fetchFn({
+                pks: currentPks,
+                modelClass: this.modelClass,
+            });
             if (pks) {
                 this.addToGroundTruth(newGroundTruth);
                 return;

package/dist/syncEngine/stores/querysetStore.d.ts

@@ -6,8 +6,17 @@ export class QuerysetStore {
     operationsMap: Map<any, any>;
     groundTruthPks: never[];
     isSyncing: boolean;
+    lastSync: number | null;
+    needsSync: boolean;
+    isTemp: any;
     pruneThreshold: any;
+    getRootStore: any;
     qsCache: Cache;
+    _lastRenderedPks: any[] | null;
+    renderCallbacks: Set<any>;
+    _rootUnregister: any;
+    _currentRootStore: any;
+    _modelStoreUnregister: any;
     get cacheKey(): any;
     onHydrated(hydratedData: any): void;
     setCache(result: any): void;
@@ -25,7 +34,17 @@ export class QuerysetStore {
     getTrimmedOperations(): any[];
     getInflightOperations(): any[];
     prune(): void;
+    registerRenderCallback(callback: any): () => boolean;
+    _ensureRootRegistration(): void;
+    /**
+     * Helper to validate PKs against the model store and apply local filtering/sorting.
+     * This is the core of the rendering logic.
+     * @private
+     */
+    private _getValidatedAndFilteredPks;
     render(optimistic?: boolean, fromCache?: boolean): any[];
+    renderFromRoot(optimistic: boolean | undefined, rootStore: any): any[];
+    renderFromData(optimistic?: boolean): any[];
     applyOperation(operation: any, currentPks: any): any;
     sync(): Promise<void>;
 }

package/dist/syncEngine/stores/querysetStore.js

@@ -1,18 +1,24 @@
 import { Operation, Status, Type, operationRegistry } from './operation.js';
 import { querysetEventEmitter } from './reactivity.js';
-import { isNil, isEmpty, trim } from 'lodash-es';
+import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
 import { modelStoreRegistry } from '../registries/modelStoreRegistry.js';
 import { processIncludedEntities } from '../../flavours/django/makeApiCall.js';
 import hash from 'object-hash';
 import { Cache } from '../cache/cache.js';
+import { filter } from "../../filtering/localFiltering.js";
+import { mod } from 'mathjs';
 export class QuerysetStore {
     constructor(modelClass, fetchFn, queryset, initialGroundTruthPks = null, initialOperations = null, options = {}) {
         this.modelClass = modelClass;
         this.fetchFn = fetchFn;
         this.queryset = queryset;
         this.isSyncing = false;
+        this.lastSync = null;
+        this.needsSync = false;
+        this.isTemp = options.isTemp || false;
         this.pruneThreshold = options.pruneThreshold || 10;
+        this.getRootStore = options.getRootStore || null;
         this.groundTruthPks = initialGroundTruthPks || [];
         this.operationsMap = new Map();
         if (Array.isArray(initialOperations)) {
@@ -22,7 +28,16 @@ export class QuerysetStore {
                 this.operationsMap.set(op.operationId, op);
             }
         }
-        this.qsCache = new Cache('queryset-cache', {}, this.onHydrated.bind(this));
+        this.qsCache = new Cache("queryset-cache", {}, this.onHydrated.bind(this));
+        this._lastRenderedPks = null;
+        this.renderCallbacks = new Set();
+        this._rootUnregister = null;
+        this._currentRootStore = null;
+        this._ensureRootRegistration();
+        const modelStore = modelStoreRegistry.getStore(this.modelClass);
+        this._modelStoreUnregister = modelStore.registerRenderCallback(() => {
+            this._emitRenderEvent();
+        });
     }
     // Caching
     get cacheKey() {
@@ -40,7 +55,7 @@ export class QuerysetStore {
     setCache(result) {
         let nonTempPks = [];
         result.forEach((pk) => {
-            if (typeof pk === 'string' && containsTempPk(pk)) {
+            if (typeof pk === "string" && containsTempPk(pk)) {
                 pk = replaceTempPks(pk);
                 if (isNil(pk) || isEmpty(trim(pk))) {
                     return;
@@ -64,7 +79,22 @@ export class QuerysetStore {
         return new Set(this.groundTruthPks);
     }
     _emitRenderEvent() {
-        querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+        const newPks = this.render(true, false);
+        // 1. Always notify direct child stores to trigger their own re-evaluation.
+        //    They will perform their own check to see if their own results have changed.
+        this.renderCallbacks.forEach((callback) => {
+            try {
+                callback();
+            }
+            catch (error) {
+                console.warn("Error in render callback:", error);
+            }
+        });
+        // 2. Only emit the global event for UI components if the final list of PKs has actually changed.
+        if (!isEqual(newPks, this._lastRenderedPks)) {
+            this._lastRenderedPks = newPks; // Update the cache with the new state
+            querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+        }
     }
     async addOperation(operation) {
         this.operationsMap.set(operation.operationId, operation);
@@ -93,9 +123,7 @@ export class QuerysetStore {
         this._emitRenderEvent();
     }
     async setGroundTruth(groundTruthPks) {
-        this.groundTruthPks = Array.isArray(groundTruthPks)
-            ? groundTruthPks
-            : [];
+        this.groundTruthPks = Array.isArray(groundTruthPks) ? groundTruthPks : [];
         this._emitRenderEvent();
     }
     async setOperations(operations) {
@@ -109,10 +137,10 @@ export class QuerysetStore {
     }
     getTrimmedOperations() {
         const cutoff = Date.now() - 1000 * 60 * 2;
-        return this.operations.filter(op => op.timestamp > cutoff);
+        return this.operations.filter((op) => op.timestamp > cutoff);
     }
     getInflightOperations() {
-        return this.operations.filter(operation => operation.status != Status.CONFIRMED &&
+        return this.operations.filter((operation) => operation.status != Status.CONFIRMED &&
             operation.status != Status.REJECTED);
     }
     prune() {
@@ -120,20 +148,68 @@ export class QuerysetStore {
         this.setGroundTruth(renderedPks);
         this.setOperations(this.getInflightOperations());
     }
+    registerRenderCallback(callback) {
+        this.renderCallbacks.add(callback);
+        return () => this.renderCallbacks.delete(callback);
+    }
+    _ensureRootRegistration() {
+        if (this.isTemp)
+            return;
+        const { isRoot, rootStore } = this.getRootStore(this.queryset);
+        // If the root store hasn't changed, nothing to do
+        if (this._currentRootStore === rootStore) {
+            return;
+        }
+        // Root store changed - clean up old registration if it exists
+        if (this._rootUnregister) {
+            this._rootUnregister();
+            this._rootUnregister = null;
+        }
+        // Set up new registration if we're derived and have a root store
+        if (!isRoot && rootStore) {
+            this._rootUnregister = rootStore.registerRenderCallback(() => {
+                this._emitRenderEvent();
+            });
+        }
+        // Update current root store reference (could be null now)
+        this._currentRootStore = rootStore;
+    }
+    /**
+     * Helper to validate PKs against the model store and apply local filtering/sorting.
+     * This is the core of the rendering logic.
+     * @private
+     */
+    _getValidatedAndFilteredPks(pks) {
+        // 1. Convert PKs to instances, filtering out any that are null (deleted).
+        const instances = Array.from(pks)
+            .map((pk) => this.modelClass.fromPk(pk, this.queryset))
+            .filter((instance) => modelStoreRegistry.getEntity(this.modelClass, instance.pk) !== null);
+        // 2. Apply the queryset's AST (filters, ordering) to the validated instances.
+        const ast = this.queryset.build();
+        const finalPks = filter(instances, ast, this.modelClass, false); // false = return PKs
+        return finalPks;
+    }
     render(optimistic = true, fromCache = false) {
+        this._ensureRootRegistration();
         if (fromCache) {
             const cachedResult = this.qsCache.get(this.cacheKey);
             if (Array.isArray(cachedResult)) {
                 return cachedResult;
             }
         }
-        const renderedPks = this.groundTruthSet;
-        for (const op of this.operations) {
-            if (op.status !== Status.REJECTED && (optimistic || op.status === Status.CONFIRMED)) {
-                this.applyOperation(op, renderedPks);
+        let pks;
+        if (this.getRootStore &&
+            typeof this.getRootStore === "function" &&
+            !this.isTemp) {
+            const { isRoot, rootStore } = this.getRootStore(this.queryset);
+            if (!isRoot && rootStore) {
+                pks = this.renderFromRoot(optimistic, rootStore);
             }
         }
-        let result = Array.from(renderedPks);
+        if (isNil(pks)) {
+            pks = this.renderFromData(optimistic);
+        }
+        let result = this._getValidatedAndFilteredPks(pks);
         let limit = this.queryset.build().serializerOptions?.limit;
         if (limit) {
             result = result.slice(0, limit);
@@ -141,12 +217,30 @@ export class QuerysetStore {
         this.setCache(result);
         return result;
     }
+    renderFromRoot(optimistic = true, rootStore) {
+        let renderedPks = rootStore.render(optimistic);
+        let renderedData = renderedPks.map((pk) => {
+            return this.modelClass.fromPk(pk, this.queryset);
+        });
+        let ast = this.queryset.build();
+        let result = filter(renderedData, ast, this.modelClass, false);
+        return result;
+    }
+    renderFromData(optimistic = true) {
+        const renderedPks = this.groundTruthSet;
+        for (const op of this.operations) {
+            if (op.status !== Status.REJECTED &&
+                (optimistic || op.status === Status.CONFIRMED)) {
+                this.applyOperation(op, renderedPks);
+            }
+        }
+        let result = Array.from(renderedPks);
+        return result;
+    }
     applyOperation(operation, currentPks) {
         const pkField = this.pkField;
         for (const instance of operation.instances) {
-            if (!instance ||
-                typeof instance !== 'object' ||
-                !(pkField in instance)) {
+            if (!instance || typeof instance !== "object" || !(pkField in instance)) {
                 console.warn(`[QuerysetStore ${this.modelClass.modelName}] Skipping instance in operation ${operation.operationId} due to missing PK '${String(pkField)}' or invalid format.`);
                 continue;
             }
@@ -175,23 +269,44 @@ export class QuerysetStore {
             console.warn(`[QuerysetStore ${id}] Already syncing, request ignored.`);
             return;
         }
+        // Check if we're delegating to a root store
+        if (this.getRootStore &&
+            typeof this.getRootStore === "function" &&
+            !this.isTemp) {
+            const { isRoot, rootStore } = this.getRootStore(this.queryset);
+            if (!isRoot && rootStore) {
+                // We're delegating to a root store - don't sync, just mark as needing sync
+                console.log(`[${id}] Delegating to root store, marking sync needed.`);
+                this.needsSync = true;
+                this.lastSync = null; // Clear last sync since we're not actually syncing
+                this.setOperations(this.getInflightOperations());
+                return;
+            }
+        }
+        // We're in independent mode - proceed with normal sync
         this.isSyncing = true;
         console.log(`[${id}] Starting sync...`);
         try {
             const response = await this.fetchFn({
                 ast: this.queryset.build(),
-                modelClass: this.modelClass
+                modelClass: this.modelClass,
             });
             const { data, included } = response;
+            if (isNil(data)) {
+                return;
+            }
             console.log(`[${id}] Sync fetch completed. Received: ${JSON.stringify(data)}.`);
             // Persists all the instances (including nested instances) to the model store
             processIncludedEntities(modelStoreRegistry, included, this.modelClass);
             this.setGroundTruth(data);
             this.setOperations(this.getInflightOperations());
+            this.lastSync = Date.now();
+            this.needsSync = false;
             console.log(`[${id}] Sync completed.`);
         }
         catch (e) {
             console.error(`[${id}] Failed to sync ground truth:`, e);
+            this.needsSync = true; // Mark as needing sync on error
         }
         finally {
             this.isSyncing = false;

package/dist/syncEngine/sync.d.ts

@@ -15,10 +15,15 @@ export class SyncManager {
     followedModels: Map<any, any>;
     followAllQuerysets: boolean;
     followedQuerysets: Map<any, any>;
+    periodicSyncTimer: NodeJS.Timeout | null;
     /**
      * Initialize event handlers for all event receivers
      */
     initialize(): void;
+    startPeriodicSync(): void;
+    syncStaleQuerysets(): void;
+    isStoreFollowed(registry: any, semanticKey: any): boolean;
+    cleanup(): void;
     followModel(registry: any, modelClass: any): void;
     unfollowModel(registry: any, modelClass: any): void;
     manageRegistry(registry: any): void;