@mindline/sync 1.0.109 → 1.0.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindline/sync",
-  "version": "1.0.109",
+  "version": "1.0.110",
   "description": "sync is a node.js package encapsulating JavaScript classes required for configuring Mindline sync service.",
   "main": "dist/sync.es.js",
   "types": "dist/index.d.ts",

package/src/index.d.ts

@@ -251,7 +251,6 @@ declare module "@mindline/sync" {
         tenantNodes: TenantNode[];
         pb_startTS: number;
         pb_progress: number;
-        pb_increment: number;
         pb_idle: number;
         pb_idleMax: number;
         pb_total: number;
@@ -268,12 +267,18 @@ declare module "@mindline/sync" {
             batchIdArray: Array<Object>,
             setRefreshDeltaTrigger: (workspace: string) => void,
             setReadersTotal: (readersTotal: number) => void,
+            setReadersExcluded: (readersExcluded: number) => void,
             setReadersCurrent: (readersCurrent: number) => void,
             setWritersTotal: (writersTotal: number) => void,
+            setWritersExcluded: (writersExcluded: number) => void,
             setWritersCurrent: (writersCurrent: number) => void,
             setMilestones: (milestones: Milestone[]) => void,
             setConfigSyncResult: (result: string) => void,
-            bClearLocalStorage: boolean): void;
+            setSyncProgress: (progress: number) => void,
+            bClearLocalStorage: boolean,
+            message: string,
+            instance?: IPublicClientApplication,
+            authorizedUser?: User): void;
         startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: SyncConfig | null | undefined): APIResult;
     }
     export class TenantNode {
@@ -359,4 +364,4 @@ declare module "@mindline/sync" {
     // ======================= Azure REST API ===============================
     export function canListRootAssignments(instance: IPublicClientApplication, user: User): Promise<boolean>;
     export function elevateGlobalAdminToUserAccessAdmin(instance: IPublicClientApplication, user: User): Promise<boolean>;
-}
+}

package/src/index.ts

@@ -1,6 +1,5 @@
 //index.ts - published interface - AAD implementations, facade to Mindline SyncConfig API
-import * as signalR from "@microsoft/signalr"
-import { AccountInfo } from "@azure/msal-common";
+import type { AccountInfo } from "@azure/msal-common";
 import { IPublicClientApplication, AuthenticationResult } from "@azure/msal-browser"
 import { deserializeArray } from 'class-transformer';
 import users from "./users.json";
@@ -918,11 +917,31 @@ export class BatchArray {
     tenantNodes: TenantNode[];
     pb_startTS: number;
     pb_progress: number;
-    pb_increment: number;
     pb_idle: number;
-    pb_idleMax: number;
     pb_total: number;
-    pb_timer: NodeJS.Timeout | null;
+    pb_timer: ReturnType<typeof setInterval> | null;
+
+    // Polling: /api/stats is the single source of truth for hydration.
+    private readonly pollIntervalSeconds: number = 5;
+    private pollTimer: ReturnType<typeof setInterval> | null = null;
+    private pollLastUpdatedByBatchId: Record<string, string> = {};
+    private pollInstance: IPublicClientApplication | null = null;
+    private pollAuthorizedUser: User | null = null;
+    private pollBatchIdArray: Array<any> = [];
+
+    // Last known backend queues (strongest completion signal)
+    private lastQueues: { main: number | null; writer: number | null; deferred: number | null } = {
+        main: null,
+        writer: null,
+        deferred: null
+    };
+    private hasQueueInfo: boolean = false;
+
+    // Store UI callbacks so we can update the UI from poll/completion events.
+    private setIdleText: ((idleText: string) => void) | null = null;
+
+    // Handler used by polling: we reuse the same stats-processing logic.
+    private statsHydrationHandler: ((batchId: string, stats: any) => void) | null = null;
     milestoneArray: MilestoneArray;
     constructor(
         config: SyncConfig | null,
@@ -933,16 +952,16 @@ export class BatchArray {
         this.init(config, syncPortalGlobalState, bClearLocalStorage);
         this.pb_startTS = 0;
         this.pb_progress = 0;
-        this.pb_increment = .25;
         this.pb_timer = null;
         this.pb_idle = 0;
-        this.pb_idleMax = 0;
         this.pb_total = 0;
         this.milestoneArray = new MilestoneArray(false);
     }
     clearStoredBatchIds(): void {
         if (storageAvailable()) {
             localStorage.setItem("BatchIdArray", "[]");
+            // Also clear any persisted UI progress for the in-flight batch restore.
+            localStorage.removeItem("BatchIdArrayProgress");
         }
     }
     // populate tenantNodes based on config tenants
@@ -1026,59 +1045,141 @@ export class BatchArray {
             });
         }
     }
-    initializeProgressBar(setSyncProgress: (progress: number) => void, setConfigSyncResult: (result: string) => void, setIdleText: (idleText: string) => void, setMilestones: (milestones: Milestone[]) => void): void {
+    initializeProgressBar(setSyncProgress: (progress: number) => void, _setConfigSyncResult: (result: string) => void, setIdleText: (idleText: string) => void, setMilestones: (milestones: Milestone[]) => void): void {
+        // Save callback so completion/polling can update the idle text too.
+        this.setIdleText = setIdleText;
+
+        // IMPORTANT: reset completion signals between sync runs.
+        // Otherwise a previous run that ended with queues=0 could make the next run immediately "Complete".
+        this.hasQueueInfo = false;
+        this.lastQueues = { main: null, writer: null, deferred: null };
+
         this.pb_startTS = Date.now();
         this.pb_progress = 0;
-        this.pb_increment = .25;
         this.pb_idle = 0;
-        this.pb_idleMax = 0;
         this.pb_total = 0;
+        setSyncProgress(this.pb_progress);
+        setIdleText("Starting sync...");
         this.pb_timer = setInterval(() => {
-            // if signalR has finished the sync, stop the timer
+            // If backend indicates completion (prefer queue-empty when available), stop the timer
             console.log("this.tenantNodes", this.tenantNodes)
-            let isCompletedOrNothingToSync = this.tenantNodes.map((tn: TenantNode) => tn.targets.map((ta) => ta.status === "complete" || tn.nothingtosync).reduce((prev, next) => prev && next)).reduce((prev, next) => prev && next);
-            if (isCompletedOrNothingToSync) {
+            let isCompletedOrNothingToSync = this.tenantNodes.every((tn: TenantNode) =>
+                tn.nothingtosync || tn.targets.every((ta) => ta.status === "complete" || ta.status === "failed")
+            );
+
+            const queuesEmpty = this.hasQueueInfo &&
+                this.lastQueues.main === 0 &&
+                this.lastQueues.writer === 0 &&
+                this.lastQueues.deferred === 0;
+
+            // If we have queue info, trust it for completion. Otherwise fall back to node terminal states.
+            const isCompleted = queuesEmpty || (!this.hasQueueInfo && isCompletedOrNothingToSync);
+
+            if (isCompleted) {
                 clearInterval(this.pb_timer!);
                 this.pb_timer = null;
                 this.pb_progress = 100;
                 setSyncProgress(this.pb_progress);
-                setIdleText(`Complete. [max idle: ${this.pb_idleMax}]`);
+                setIdleText(`Complete.`);
+                this.stopPolling();
                 this.clearStoredBatchIds();
             }
             else {
-                // if we've gone 60 seconds without a signalR message, finish the sync
                 this.pb_total = this.pb_total + 1;
                 this.pb_idle = this.pb_idle + 1;
-                this.pb_idleMax = Math.max(this.pb_idle, this.pb_idleMax);
-                setIdleText(`${this.pb_total} seconds elapsed. Last update ${this.pb_idle} seconds ago. [max idle: ${this.pb_idleMax}/60]`);
-                if (this.pb_idle >= 60) {
-                    if (this.milestoneArray.milestones[0].Write == null) {
-                        //this.milestoneArray.write(setMilestones); -- allow sync to cntinue
-                        setConfigSyncResult(`sync continuing, but no update for ${this.pb_idle} seconds`);
-                    }
-                }
-                // if we get to 100, the progress bar stops but SignalR or countdown timer completes the sync
-                if (this.pb_progress < 100) {
-                    this.pb_progress = Math.min(100, this.pb_progress + this.pb_increment);
-                    setSyncProgress(this.pb_progress);
-                }
+
+                setIdleText(`${this.pb_total} seconds elapsed. Last update ${this.pb_idle} seconds ago.`);
             }
         }, 1000);
         this.milestoneArray.start(setMilestones);
     }
+
+    private stopPolling(): void {
+        if (this.pollTimer != null) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        this.pollInstance = null;
+        this.pollAuthorizedUser = null;
+        this.pollBatchIdArray = [];
+        this.pollLastUpdatedByBatchId = {};
+    }
+
+    private async pollStatsOnce(): Promise<void> {
+        // Polling-only mode (single source of truth: /api/stats).
+        if (this.pb_timer == null) return;
+        if (this.pollInstance == null || this.pollAuthorizedUser == null) return;
+        if (!this.statsHydrationHandler) return;
+        if (!this.pollBatchIdArray || this.pollBatchIdArray.length === 0) return;
+
+        for (const batchPair of this.pollBatchIdArray) {
+            const batchId: string | undefined = batchPair?.BatchId;
+            if (!batchId) continue;
+
+            const statsResult: APIResult = await readerStats(this.pollInstance, this.pollAuthorizedUser, batchId);
+            if (!statsResult.result || !statsResult.array || !statsResult.array[0]) continue;
+
+            const payload: any = statsResult.array[0];
+            const lastUpdated: string | undefined = payload.lastUpdated;
+            const prevLastUpdated = this.pollLastUpdatedByBatchId[batchId];
+            this.pollLastUpdatedByBatchId[batchId] = lastUpdated ?? "";
+
+            // Only feed the handler if backend state changed.
+            if (!lastUpdated || lastUpdated === prevLastUpdated) continue;
+
+            this.statsHydrationHandler(batchId, payload.stats);
+        }
+    }
     uninitializeProgressBar(setSyncProgress: (progress: number) => void, setConfigSyncResult: (result: string) => void, setIdleText: (idleText: string) => void, setMilestones: (milestones: Milestone[]) => void): void {
         this.pb_startTS = 0;
         this.pb_progress = 0;
         setSyncProgress(this.pb_progress);
         setConfigSyncResult("sync failed to execute");
-        this.pb_increment = 0;
         clearInterval(this.pb_timer!);
         this.pb_timer = null;
         this.pb_idle = 0;
-        this.pb_idleMax = 0;
-        setIdleText(`No updates seen for ${this.pb_idle} seconds. [max idle: ${this.pb_idleMax}]`);
+        setIdleText(`No updates seen for ${this.pb_idle} seconds.`);
         this.milestoneArray.unstart(setMilestones);
     }
+    /**
+     * Calculates the sync progress percentage (0-99%) based on completed read and write operations.
+     *
+     * The progress formula is: (completedReads + completedWrites) / (total * 2) * 100
+     *
+     * Progress is divided by (total * 2) because the sync process has two phases:
+     * 1. Reading phase: read users from source + excluded users
+     * 2. Writing phase: write users to target + excluded users + deferred users
+     *
+     * Each phase can contribute up to 50% of the total progress. The result is capped at 99%
+     * to prevent premature completion (100% is only shown when sync is truly complete).
+     *
+     * @param total - Total number of users to sync
+     * @param read - Number of users read from source
+     * @param written - Number of users written to target
+     * @param excluded - Number of users excluded from sync
+     * @param deferred - Number of users deferred (postponed) during writing
+     * @returns Progress percentage from 0 to 99
+     */
+    calculateProgress(total: number, read: number, written: number, excluded: number, deferred: number): number {
+        if (total <= 0) {
+            return 0;
+        }
+        const completedReads = Math.min(total, read + excluded);
+        const completedWrites = Math.min(total, written + excluded + deferred);
+        const completedUnits = completedReads + completedWrites;
+        return Math.min(99, Math.round((completedUnits / (total * 2)) * 100));
+    }
+    updateProgressFromTotals(total: number, read: number, written: number, excluded: number, deferred: number, setSyncProgress: (progress: number) => void): void {
+        const progress = this.calculateProgress(total, read, written, excluded, deferred);
+        this.pb_progress = Math.max(this.pb_progress, progress);
+        setSyncProgress(this.pb_progress);
+
+        // Persist progress so a page refresh can restore the same (or higher) percent.
+        // Note: This is intentionally monotonic because pb_progress is monotonic.
+        if (storageAvailable()) {
+            localStorage.setItem("BatchIdArrayProgress", String(this.pb_progress));
+        }
+    }
     initializeSignalR(
         config: SyncConfig | null | undefined,
         syncPortalGlobalState: InitInfo | null,
@@ -1092,25 +1193,32 @@ export class BatchArray {
         setWritersCurrent: (writersCurrent: number) => void,
         setMilestones: (milestones: Milestone[]) => void,
         setConfigSyncResult: (result: string) => void,
+        setSyncProgress: (progress: number) => void,
         bClearLocalStorage: boolean,
-        message: string
+        message: string,
+        instance?: IPublicClientApplication,
+        authorizedUser?: User
     ): void {
         bClearLocalStorage = bClearLocalStorage;
+        message = message;
+
+        // Starting a new SignalR session for a (potentially new) run: reset queue-based completion signals.
+        this.hasQueueInfo = false;
+        this.lastQueues = { main: null, writer: null, deferred: null };
+
         // we have just completed a successful POST to startSync
         this.milestoneArray.post(setMilestones);
         setConfigSyncResult("started sync, waiting for updates...");
         // re-initialize batch array with Configuration updated by the succcessful POST to startSync
         this.init(config, syncPortalGlobalState, false);
-        // define newMessage handler that can access *this*
-        let handler = (connection: signalR.HubConnection) => (message: string) => {
-            console.log(message);
-            let item = JSON.parse(message);
+        // define a stats hydration handler (used by polling)
+        let handler = (batchId: string, statsarray: any) => {
             // reset the countdown timer every time we get a message
             this.pb_idle = 0;
-            // find the associated tenant for this SignalR message
-            let matchingPair: any | undefined = batchIdArray.find((o: any) => o.BatchId == item.TargetID);
+            // find the associated tenant for this batchId
+            let matchingPair: any | undefined = batchIdArray.find((o: any) => o.BatchId == batchId);
             if (matchingPair == null) {
-                console.log(`Batch ${item.TargetID} not found in batchIdArray.`);
+                console.log(`Batch ${batchId} not found in batchIdArray.`);
                 debugger;
                 return;
             }
@@ -1121,13 +1229,16 @@ export class BatchArray {
                 return;
             }
             tenantNode.batchId = matchingPair.BatchId;
-            // process stats for this SignalR message (one batch per tenant node)
-            let statsarray = item.Stats; // get the array of statistics
+            // process stats for this batch (one batch per tenant node)
             let statskeys = Object.keys(statsarray); // get the keys of the array
             let statsvalues = Object.values(statsarray); // get the values of the array
             // does this tenantnode/batch have nothing to sync?
             let bTotalCountZero: boolean = false;
             let bCurrentCountZero: boolean = false;
+            // queue stats (better completion signal than only written/total)
+            let totalInMainQueue: number | null = null;
+            let totalInWriterQueue: number | null = null;
+            let totalInDeferredQueue: number | null = null;
             for (let j = 0; j < statskeys.length; j++) {
                 let bTotalCount = statskeys[j].endsWith("TotalCount");
                 let bCurrentCount = statskeys[j].endsWith("CurrentCount");
@@ -1180,9 +1291,21 @@ export class BatchArray {
                     }
                 }
                 tenantNode.nothingtosync = bTotalCountZero && bCurrentCountZero;
+
+                // queue stats are global for the batch
+                if (statskeys[j] === "TotalInMainQueue") {
+                    totalInMainQueue = Number(statsvalues[j]);
+                }
+                if (statskeys[j] === "TotalInWriterQueue") {
+                    totalInWriterQueue = Number(statsvalues[j]);
+                }
+                if (statskeys[j] === "TotalInDeferredQueue") {
+                    totalInDeferredQueue = Number(statsvalues[j]);
+                }
+
                 if (statskeys[j].startsWith("Writer")) {
                     // parse tid from Writer key
-                    let tidRegexp = /Reader\/TID:(.+)\/TotalCount/;
+                    let tidRegexp = /Writer\/TID:(.+)\/TotalCount/;
                     if (bCurrentCount) tidRegexp = /Writer\/TID:(.+)\/CurrentCount/;
                     if (bExcludedCount) tidRegexp = /Writer\/TID:(.+)\/ExtCount/;
                     if (bDeferredCount) tidRegexp = /Writer\/TID:(.+)\/DeferredCount/;
@@ -1204,7 +1327,7 @@ export class BatchArray {
                     writerNode.total = Math.max(Number(tenantNode.total), writerNode.total);
                     writerNode.batchId = matchingPair.BatchId;
                     if (bTotalCount) {
-                        writerNode.total = Math.max(Number(bTotalCount), writerNode.total);
+                        writerNode.total = Math.max(Number(statsvalues[j]), writerNode.total);
                         console.log(`----- ${writerNode.name} TID: ${writerNode.tid} batchId: ${writerNode.batchId}`);
                         console.log(`----- ${writerNode.name} Total To Write: ${writerNode.total}`);
                     }
@@ -1238,6 +1361,7 @@ export class BatchArray {
             let writerTotal: number = 0;
             let writerCurrent: number = 0;
             let writerExcluded: number = 0;
+            let writerDeferred: number = 0;
             this.tenantNodes.map((sourceTenantNode: TenantNode) => {
                 sourceTenantNode.targets.map((writerNode: TenantNode) => {
                     bWritingComplete &&= (writerNode.status == "complete" || writerNode.status == "failed");
@@ -1245,13 +1369,40 @@ export class BatchArray {
                     writerTotal += Math.max(writerNode.total, sourceTenantNode.total);
                     writerCurrent += writerNode.written;
                     writerExcluded += writerNode.excluded;
+                    writerDeferred += writerNode.deferred;
                 });
                 bNothingToSync &&= sourceTenantNode.nothingtosync;
-                bReadingComplete &&= (sourceTenantNode.status == "complete" || sourceTenantNode.status == "failed");
+                // Reading completion should be derived from read/excluded totals, not from source status.
+                bReadingComplete &&= (sourceTenantNode.total > 0 && (sourceTenantNode.read + sourceTenantNode.excluded) >= sourceTenantNode.total);
                 readerTotal += sourceTenantNode.total;
                 readerCurrent += sourceTenantNode.read;
                 readerExcluded += sourceTenantNode.excluded;
             });
+
+            // If queue stats are available, they are a stronger indicator of write completion.
+            // When all queues are empty, the backend has finished processing this batch and may stop emitting updates.
+            if (totalInMainQueue != null) this.lastQueues.main = totalInMainQueue;
+            if (totalInWriterQueue != null) this.lastQueues.writer = totalInWriterQueue;
+            if (totalInDeferredQueue != null) this.lastQueues.deferred = totalInDeferredQueue;
+            this.hasQueueInfo = this.lastQueues.main != null && this.lastQueues.writer != null && this.lastQueues.deferred != null;
+
+            const queuesEmpty = this.hasQueueInfo &&
+                this.lastQueues.main === 0 &&
+                this.lastQueues.writer === 0 &&
+                this.lastQueues.deferred === 0;
+
+            if (queuesEmpty) {
+                bWritingComplete = true;
+
+                // Ensure the UI can reach a terminal state even if writer CurrentCount never reaches TotalCount.
+                // We trust the backend queues more than client-side totals in this scenario.
+                this.tenantNodes.forEach((src) => {
+                    src.targets.forEach((t) => {
+                        if (t.status !== "failed") t.status = "complete";
+                    });
+                    if (src.status !== "failed") src.status = "complete";
+                });
+            }
             // set linear gauge max and current values
             setReadersTotal(readerTotal);
             setReadersCurrent(readerCurrent);
@@ -1259,11 +1410,33 @@ export class BatchArray {
             setWritersTotal(Math.max(writerTotal, readerTotal));
             setWritersCurrent(writerCurrent);
             setWritersExcluded(writerExcluded);
+
+            // update progress bar based on backend totals (monotonic)
+            // This avoids progress decreasing after refresh when local timer state restarts.
+            // Excluded users count as completed for both read and write.
+            // Deferred users count as completed for write.
+            this.updateProgressFromTotals(
+                Math.max(readerTotal, writerTotal),
+                readerCurrent,
+                writerCurrent,
+                Math.max(readerExcluded, writerExcluded),
+                // Deferred users count as completed for write.
+                writerDeferred,
+                setSyncProgress
+            );
             // check to see if there was nothing to sync
             if (bNothingToSync) {
                 this.milestoneArray.write(setMilestones);
-                connection.stop();
+                this.stopPolling();
                 setConfigSyncResult("nothing to sync");
+                // force completion visuals
+                if (this.pb_timer) {
+                    clearInterval(this.pb_timer);
+                    this.pb_timer = null;
+                }
+                this.pb_progress = 100;
+                setSyncProgress(this.pb_progress);
+                this.setIdleText?.(`Complete (nothing to sync).`);
                 this.clearStoredBatchIds();
                 console.log(`Setting config sync result: "nothing to sync"`);
             }
@@ -1275,19 +1448,21 @@ export class BatchArray {
                     console.log(`Setting config sync result: "reading complete"`);
                     // trigger refresh delta tokens
                     setRefreshDeltaTrigger(config!.workspaceId);
-                    // change to % per second to complete in 12x as long as it took to get here
-                    let readTS = Date.now();
-                    let secsElapsed = (readTS - this.pb_startTS) / 1000;
-                    let expectedPercentDone = 8.5;
-                    let expectedPercentPerSecond = secsElapsed / expectedPercentDone;
-                    this.pb_increment = expectedPercentPerSecond;
-                    console.log(`Setting increment: ${this.pb_increment}% per second`);
                 }
                 // with that out of the way, is writing complete?
-                if (bWritingComplete) {
+                // Only allow terminal completion when backend queues are empty (if we have queue info).
+                if (bWritingComplete && (queuesEmpty || !this.hasQueueInfo)) {
                     this.milestoneArray.write(setMilestones);
-                    connection.stop();
+                    this.stopPolling();
                     setConfigSyncResult("sync complete");
+                    // force completion visuals
+                    if (this.pb_timer) {
+                        clearInterval(this.pb_timer);
+                        this.pb_timer = null;
+                    }
+                    this.pb_progress = 100;
+                    setSyncProgress(this.pb_progress);
+                    this.setIdleText?.(`Complete.`);
                     this.clearStoredBatchIds();
                     console.log(`Setting config sync result: "complete"`);
                 }
@@ -1304,38 +1479,26 @@ export class BatchArray {
             }
         }
 
-        // start SignalR connection based on each batchId
-        batchIdArray.map((batchPair: any) => {
-            const endpoint: string = mindlineConfig.signalREndpoint();
-            let endpointUrl: URL = new URL(endpoint);
-            endpointUrl.searchParams.append("statsId", batchPair.BatchId);
-            console.log(`Creating SignalR Hub for TID: ${batchPair.SourceId} ${endpointUrl.href}`);
-            const connection: signalR.HubConnection = new signalR.HubConnectionBuilder()
-                .withUrl(endpointUrl.href)
-                .withAutomaticReconnect()
-                .configureLogging(signalR.LogLevel.Information)
-                .build();
-            // when you get a message, process the message
-            if (!!message && JSON.parse(message).TargetID === batchPair.BatchId) {
-                handler(connection)(message)
-            }
-            connection.on("newMessage", handler(connection));
-            connection.onreconnecting(error => {
-                console.assert(connection.state === signalR.HubConnectionState.Reconnecting);
-                console.log(`Connection lost due to error "${error}". Reconnecting.`);
-            });
-            connection.onreconnected(connectionId => {
-                console.assert(connection.state === signalR.HubConnectionState.Connected);
-                console.log(`Connection reestablished. Connected with connectionId "${connectionId}".`);
-            });
-            // restart when you get a close event
-            connection.onclose(async () => {
-                console.log(`Connection closing. Attempting restart.`);
-                await connection.start();
-            });
-            // start and display any caught exceptions in the console
-            connection.start().catch(console.error);
-        });
+        // allow polling to feed the same handler
+        this.statsHydrationHandler = handler;
+
+        // Start polling (only if caller provided credentials)
+        if (instance && authorizedUser) {
+            this.pollInstance = instance;
+            this.pollAuthorizedUser = authorizedUser;
+            this.pollBatchIdArray = batchIdArray as any[];
+            this.stopPolling(); // clear any previous poller state
+            this.pollInstance = instance;
+            this.pollAuthorizedUser = authorizedUser;
+            this.pollBatchIdArray = batchIdArray as any[];
+
+            // Hydrate immediately (no need to wait pollIntervalSeconds)
+            void this.pollStatsOnce();
+
+            this.pollTimer = setInterval(() => {
+                void this.pollStatsOnce();
+            }, this.pollIntervalSeconds * 1000);
+        }
     }
     // start a sync cycle
     async startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: SyncConfig | null | undefined): Promise<APIResult> {
@@ -1383,8 +1546,20 @@ export class TenantNode {
         this.deferred = deferred;
         if (this.read === 0 && this.written === 0) this.status = "not started";
         if (this.read > 0) {
-            if (this.read + this.excluded < this.total) this.status = "in progress";
-            else if (this.read + this.excluded === this.total) this.status = "complete";
+            if (this.read + this.excluded < this.total) {
+                this.status = "in progress";
+            }
+            else if (this.read + this.excluded === this.total) {
+                // For source nodes (nodes with targets), reading complete doesn't mean the whole branch is complete.
+                // Avoid reporting "complete" while any target is still running.
+                if (this.targets != null && this.targets.length > 0) {
+                    const allTargetsTerminal = this.targets.every(t => t.status === "complete" || t.status === "failed");
+                    this.status = allTargetsTerminal ? "complete" : "in progress";
+                }
+                else {
+                    this.status = "complete";
+                }
+            }
         }
         else if (this.written > 0) {
             if (this.written + this.deferred + this.excluded < this.total) this.status = "in progress";