@taskforcehq/taskforce 0.3.168

package/dist/hooks/useWorkspaceSyncController.js

@@ -0,0 +1,598 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { calculateWorkspaceRetryDelayMs } from '../sync/syncService';
+import { bootstrapPushWorkspaceSnapshot } from '../sync/cloudSyncApi';
+const WORKSPACE_PULL_LEASE_KEY_PREFIX = 'taskforce.sync.pullLease.v1';
+const WORKSPACE_PULL_COOLDOWN_KEY_PREFIX = 'taskforce.sync.pullCooldown.v1';
+const WORKSPACE_PULL_LEASE_MS = 30_000;
+const WORKSPACE_PULL_MIN_INTERVAL_MS = 10_000;
+const SYNC_DEBUG_LOG_KEY = 'taskforce.syncDebug.v1';
+function isSyncDebugLoggingEnabled() {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        const raw = String(window.localStorage.getItem(SYNC_DEBUG_LOG_KEY) || '').trim().toLowerCase();
+        return raw === '1' || raw === 'true' || raw === 'on' || raw === 'yes';
+    }
+    catch {
+        return false;
+    }
+}
+function logSyncDebug(event, details) {
+    if (!isSyncDebugLoggingEnabled())
+        return;
+    const payload = details && typeof details === 'object' ? details : {};
+    console.info('[Taskforce Sync]', event, payload);
+}
+function getWorkspacePullLeaseStorageKey(workspaceId) {
+    return `${WORKSPACE_PULL_LEASE_KEY_PREFIX}.${workspaceId}`;
+}
+function getWorkspacePullCooldownStorageKey(workspaceId) {
+    return `${WORKSPACE_PULL_COOLDOWN_KEY_PREFIX}.${workspaceId}`;
+}
+function isValidWorkspaceKey(workspaceId) {
+    const workspaceKey = String(workspaceId || '').trim();
+    return workspaceKey.length > 0 && workspaceKey.toLowerCase() !== 'default';
+}
+export function useWorkspaceSyncController(input) {
+    const { currentWorkspaceId, setWorkspaceSyncReady, setWorkspaceCloudHydrated, setWorkspaceCloudSyncEnabled, setWorkspaceSyncSourceOfTruth, setWorkspaceSyncOnboardingCompleted, setUserGlobalLastSyncedAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt } = input;
+    const [workspaceRetryAt, setWorkspaceRetryAt] = useState(null);
+    const [workspaceBootstrapSyncInProgress, setWorkspaceBootstrapSyncInProgress] = useState(false);
+    const [workspaceBootstrapSyncPages, setWorkspaceBootstrapSyncPages] = useState(0);
+    const [workspaceBootstrapSyncAppliedChanges, setWorkspaceBootstrapSyncAppliedChanges] = useState(0);
+    const [workspaceSyncFailureCount, setWorkspaceSyncFailureCount] = useState(0);
+    const [workspaceSyncRetryScheduledCount, setWorkspaceSyncRetryScheduledCount] = useState(0);
+    const [workspaceSyncAuthFailureCount, setWorkspaceSyncAuthFailureCount] = useState(0);
+    const [workspaceSyncLastFailureSource, setWorkspaceSyncLastFailureSource] = useState(null);
+    const [workspaceSyncLastFailureStatusCode, setWorkspaceSyncLastFailureStatusCode] = useState(null);
+    const workspacePushInFlightRef = useRef(false);
+    const workspacePullInFlightRef = useRef(false);
+    const workspaceRetryTimerRef = useRef(null);
+    const workspaceRetryAtMsRef = useRef(null);
+    const workspaceRetryAttemptRef = useRef(0);
+    const workspaceLastPushedSignatureRef = useRef('');
+    const workspacePendingSignatureRef = useRef('');
+    const workspaceLastPushedTaskIdsRef = useRef(new Set());
+    const workspaceDeletedTaskIdsRef = useRef(new Set());
+    const workspacePullCursorRef = useRef(null);
+    const workspacePullBootstrapDoneRef = useRef(false);
+    const workspaceBackfillForcedRef = useRef(new Set());
+    const workspaceSyncReadyRef = useRef(new Set());
+    const workspaceCloudHydratedRef = useRef(new Set());
+    const workspaceSyncStateReadCountRef = useRef(0);
+    const workspacePullLeaseOwnerRef = useRef('');
+    const activeLockWorkspaceIdRef = useRef(null);
+    const activeLockAbortControllerRef = useRef(null);
+    const onFailureRecordedRef = useRef(input.onFailureRecorded);
+    useEffect(() => {
+        onFailureRecordedRef.current = input.onFailureRecorded;
+    }, [input.onFailureRecorded]);
+    if (!workspacePullLeaseOwnerRef.current) {
+        const now = Date.now().toString(36);
+        const rand = Math.random().toString(36).slice(2, 10);
+        workspacePullLeaseOwnerRef.current = `pull-${now}-${rand}`;
+    }
+    const clearWorkspaceRetry = useCallback(() => {
+        workspaceRetryAttemptRef.current = 0;
+        workspaceRetryAtMsRef.current = null;
+        if (workspaceRetryTimerRef.current !== null && typeof window !== 'undefined') {
+            window.clearTimeout(workspaceRetryTimerRef.current);
+            workspaceRetryTimerRef.current = null;
+        }
+        setWorkspaceRetryAt(null);
+    }, []);
+    const scheduleWorkspacePullRetry = useCallback((invokePull, options) => {
+        if (typeof window === 'undefined')
+            return;
+        setWorkspaceSyncRetryScheduledCount((prev) => prev + 1);
+        const attempt = workspaceRetryAttemptRef.current + 1;
+        workspaceRetryAttemptRef.current = attempt;
+        const computedDelayMs = calculateWorkspaceRetryDelayMs(attempt);
+        const explicitDelayMs = Number(options?.minDelayMs);
+        const delayMs = Number.isFinite(explicitDelayMs) && explicitDelayMs > 0
+            ? Math.max(computedDelayMs, Math.floor(explicitDelayMs))
+            : computedDelayMs;
+        const retryAtMs = Date.now() + delayMs;
+        const retryAtIso = new Date(Date.now() + delayMs).toISOString();
+        const workspaceKey = String(options?.workspaceId || '').trim();
+        if (workspaceKey) {
+            try {
+                const cooldownKey = getWorkspacePullCooldownStorageKey(workspaceKey);
+                const raw = window.localStorage.getItem(cooldownKey);
+                const parsed = raw ? JSON.parse(raw) : null;
+                const existingNextAt = Number(parsed?.nextAllowedAt || 0);
+                const nextAllowedAt = Math.max(existingNextAt, retryAtMs);
+                window.localStorage.setItem(cooldownKey, JSON.stringify({ nextAllowedAt }));
+            }
+            catch {
+                // best-effort only
+            }
+        }
+        workspaceRetryAtMsRef.current = retryAtMs;
+        setWorkspaceRetryAt(retryAtIso);
+        if (workspaceRetryTimerRef.current !== null) {
+            window.clearTimeout(workspaceRetryTimerRef.current);
+        }
+        workspaceRetryTimerRef.current = window.setTimeout(() => {
+            workspaceRetryTimerRef.current = null;
+            workspaceRetryAtMsRef.current = null;
+            setWorkspaceRetryAt(null);
+            if (workspaceKey) {
+                try {
+                    const cooldownKey = getWorkspacePullCooldownStorageKey(workspaceKey);
+                    const raw = window.localStorage.getItem(cooldownKey);
+                    const parsed = raw ? JSON.parse(raw) : null;
+                    const nextAllowedAt = Number(parsed?.nextAllowedAt || 0);
+                    if (Number.isFinite(nextAllowedAt) && nextAllowedAt <= retryAtMs) {
+                        window.localStorage.setItem(cooldownKey, JSON.stringify({ nextAllowedAt: Date.now() - 1 }));
+                    }
+                }
+                catch {
+                    // best-effort only
+                }
+            }
+            void invokePull();
+        }, delayMs);
+    }, []);
+    const isWorkspacePullRetryPending = useCallback(() => {
+        const retryAtMs = workspaceRetryAtMsRef.current;
+        return typeof retryAtMs === 'number' && Number.isFinite(retryAtMs) && retryAtMs > Date.now();
+    }, []);
+    const isWorkspacePullCooldownActive = useCallback((workspaceId) => {
+        if (typeof window === 'undefined')
+            return false;
+        const workspaceKey = String(workspaceId || '').trim();
+        if (!workspaceKey)
+            return false;
+        try {
+            const raw = window.localStorage.getItem(getWorkspacePullCooldownStorageKey(workspaceKey));
+            const parsed = raw ? JSON.parse(raw) : null;
+            const nextAllowedAt = Number(parsed?.nextAllowedAt || 0);
+            return Number.isFinite(nextAllowedAt) && nextAllowedAt > Date.now();
+        }
+        catch {
+            return false;
+        }
+    }, []);
+    const markWorkspacePullCooldown = useCallback((workspaceId, minDelayMs) => {
+        if (typeof window === 'undefined')
+            return;
+        const workspaceKey = String(workspaceId || '').trim();
+        if (!workspaceKey)
+            return;
+        try {
+            const cooldownKey = getWorkspacePullCooldownStorageKey(workspaceKey);
+            const raw = window.localStorage.getItem(cooldownKey);
+            const parsed = raw ? JSON.parse(raw) : null;
+            const existingNextAt = Number(parsed?.nextAllowedAt || 0);
+            const explicitDelayMs = Number(minDelayMs);
+            const baselineDelay = Number.isFinite(explicitDelayMs) && explicitDelayMs > 0
+                ? Math.max(WORKSPACE_PULL_MIN_INTERVAL_MS, Math.floor(explicitDelayMs))
+                : WORKSPACE_PULL_MIN_INTERVAL_MS;
+            const nextAllowedAt = Math.max(existingNextAt, Date.now() + baselineDelay);
+            window.localStorage.setItem(cooldownKey, JSON.stringify({ nextAllowedAt }));
+        }
+        catch {
+            // best-effort only
+        }
+    }, []);
+    const tryAcquireWorkspacePullLease = useCallback(async (workspaceId) => {
+        const workspaceKey = String(workspaceId || '').trim();
+        if (!workspaceKey)
+            return true;
+        const fallbackAcquire = () => {
+            if (typeof window === 'undefined')
+                return true;
+            try {
+                const leaseKey = getWorkspacePullLeaseStorageKey(workspaceKey);
+                const ownerId = workspacePullLeaseOwnerRef.current;
+                const now = Date.now();
+                const raw = window.localStorage.getItem(leaseKey);
+                const parsed = raw ? JSON.parse(raw) : null;
+                const existingOwner = typeof parsed?.owner === 'string' ? parsed.owner : '';
+                const existingExpiresAt = Number(parsed?.expiresAt || 0);
+                const leaseActive = Number.isFinite(existingExpiresAt) && existingExpiresAt > now;
+                if (leaseActive && existingOwner && existingOwner !== ownerId)
+                    return false;
+                const nextLease = {
+                    owner: ownerId,
+                    acquiredAt: now,
+                    expiresAt: now + WORKSPACE_PULL_LEASE_MS
+                };
+                window.localStorage.setItem(leaseKey, JSON.stringify(nextLease));
+                const verifyRaw = window.localStorage.getItem(leaseKey);
+                const verify = verifyRaw ? JSON.parse(verifyRaw) : null;
+                return verify?.owner === ownerId;
+            }
+            catch {
+                return true;
+            }
+        };
+        if (typeof window === 'undefined' || typeof navigator === 'undefined' || !navigator.locks) {
+            return fallbackAcquire();
+        }
+        if (activeLockAbortControllerRef.current) {
+            return activeLockWorkspaceIdRef.current === workspaceKey; // Already holding the lock for this workspace
+        }
+        const lockName = `taskforce.sync.pullLock.${workspaceKey}`;
+        const controller = new AbortController();
+        try {
+            const acquired = await new Promise((resolve) => {
+                navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true, signal: controller.signal }, async (lock) => {
+                    if (!lock) {
+                        resolve(false);
+                        return;
+                    }
+                    activeLockAbortControllerRef.current = controller;
+                    activeLockWorkspaceIdRef.current = workspaceKey;
+                    resolve(true);
+                    // Hold the lock indefinitely until aborted
+                    return new Promise(() => { });
+                }).catch(() => {
+                    resolve(false);
+                });
+            });
+            return acquired;
+        }
+        catch {
+            return fallbackAcquire();
+        }
+    }, []);
+    const releaseWorkspacePullLease = useCallback((workspaceId) => {
+        const workspaceKey = String(workspaceId || '').trim();
+        if (workspaceKey
+            && activeLockWorkspaceIdRef.current
+            && activeLockWorkspaceIdRef.current !== workspaceKey) {
+            return;
+        }
+        if (activeLockAbortControllerRef.current) {
+            activeLockAbortControllerRef.current.abort();
+            activeLockAbortControllerRef.current = null;
+        }
+        activeLockWorkspaceIdRef.current = null;
+        if (!workspaceKey || typeof window === 'undefined')
+            return;
+        try {
+            const leaseKey = getWorkspacePullLeaseStorageKey(workspaceKey);
+            const raw = window.localStorage.getItem(leaseKey);
+            const parsed = raw ? JSON.parse(raw) : null;
+            if (parsed?.owner === workspacePullLeaseOwnerRef.current) {
+                window.localStorage.removeItem(leaseKey);
+            }
+        }
+        catch {
+            // best-effort only
+        }
+    }, []);
+    const recordWorkspaceSyncFailure = useCallback((source, statusCode) => {
+        const normalizedStatusCode = typeof statusCode === 'number' && Number.isFinite(statusCode) ? statusCode : null;
+        setWorkspaceSyncFailureCount((prev) => prev + 1);
+        setWorkspaceSyncLastFailureSource(source);
+        setWorkspaceSyncLastFailureStatusCode(normalizedStatusCode);
+        const onFailureRecorded = onFailureRecordedRef.current;
+        if (onFailureRecorded)
+            onFailureRecorded(source, normalizedStatusCode);
+    }, []);
+    const incrementWorkspaceSyncAuthFailure = useCallback(() => {
+        setWorkspaceSyncAuthFailureCount((prev) => prev + 1);
+    }, []);
+    const persistWorkspaceSyncPatch = useCallback(async (patch) => {
+        if (!isValidWorkspaceKey(currentWorkspaceId))
+            return;
+        try {
+            await fetch('/api/taskforce/ui-state', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({
+                    workspaceId: currentWorkspaceId,
+                    stateKey: 'workspace-sync',
+                    patch: {
+                        ...patch,
+                        updatedAt: new Date().toISOString()
+                    }
+                })
+            });
+        }
+        catch {
+            // ignore persistence errors
+        }
+    }, [currentWorkspaceId]);
+    const loadWorkspaceSyncState = useCallback(async () => {
+        const workspaceId = String(currentWorkspaceId || '').trim();
+        if (!isValidWorkspaceKey(workspaceId)) {
+            setWorkspaceCloudSyncEnabled(false);
+            setWorkspaceSyncSourceOfTruth(null);
+            setWorkspaceSyncOnboardingCompleted(false);
+            workspacePullCursorRef.current = null;
+            workspacePullBootstrapDoneRef.current = false;
+            logSyncDebug('workspace_sync_state_read_skipped_invalid_workspace', { workspaceId });
+            return;
+        }
+        workspaceSyncStateReadCountRef.current += 1;
+        const readCount = workspaceSyncStateReadCountRef.current;
+        try {
+            const res = await fetch(`/api/taskforce/ui-state?key=workspace-sync&workspaceId=${encodeURIComponent(workspaceId)}`, {
+                method: 'GET',
+                credentials: 'include'
+            });
+            if (!res.ok) {
+                logSyncDebug('workspace_sync_state_read_failed', {
+                    workspaceId,
+                    readCount,
+                    status: res.status
+                });
+                if (res.status === 429) {
+                    logSyncDebug('workspace_sync_state_rate_limited', {
+                        workspaceId,
+                        readCount
+                    });
+                }
+                return;
+            }
+            const data = await res.json().catch(() => ({}));
+            const state = (data?.state && typeof data.state === 'object')
+                ? data.state
+                : null;
+            if (!state) {
+                logSyncDebug('workspace_sync_state_read_empty', {
+                    workspaceId,
+                    readCount
+                });
+                return;
+            }
+            setWorkspaceCloudSyncEnabled(Boolean(state.cloudSyncEnabled));
+            const source = String(state.sourceOfTruth || '').trim().toLowerCase();
+            if (source === 'cloud' || source === 'local') {
+                setWorkspaceSyncSourceOfTruth(source);
+            }
+            else {
+                setWorkspaceSyncSourceOfTruth(null);
+            }
+            setWorkspaceSyncOnboardingCompleted(Boolean(state.onboardingCompleted));
+            const lastSyncedAt = typeof state.lastSyncedAt === 'string' ? state.lastSyncedAt : '';
+            if (lastSyncedAt.trim().length > 0) {
+                setUserGlobalLastSyncedAt(lastSyncedAt.trim());
+            }
+            const lastPullAt = typeof state.lastPullAt === 'string' ? state.lastPullAt : '';
+            if (lastPullAt.trim().length > 0) {
+                setWorkspaceLastPullAt(lastPullAt.trim());
+            }
+            const lastPushAt = typeof state.lastPushAt === 'string' ? state.lastPushAt : '';
+            if (lastPushAt.trim().length > 0) {
+                setWorkspaceLastPushAt(lastPushAt.trim());
+            }
+            const pullCursor = typeof state.pullCursor === 'string' ? state.pullCursor : '';
+            const trimmedCursor = pullCursor.trim();
+            workspacePullCursorRef.current = trimmedCursor.length > 0 ? trimmedCursor : null;
+            // Only mark bootstrap done if we actually have a valid persisted cursor.
+            // An empty cursor means the previous bootstrap was incomplete; let it re-run.
+            workspacePullBootstrapDoneRef.current = trimmedCursor.length > 0;
+            logSyncDebug('workspace_sync_state_read_ok', {
+                workspaceId,
+                readCount,
+                sourceOfTruth: source === 'cloud' || source === 'local' ? source : null,
+                cloudSyncEnabled: Boolean(state.cloudSyncEnabled)
+            });
+        }
+        catch {
+            logSyncDebug('workspace_sync_state_read_exception', {
+                workspaceId,
+                readCount
+            });
+        }
+    }, [
+        currentWorkspaceId,
+        setWorkspaceCloudSyncEnabled,
+        setWorkspaceSyncSourceOfTruth,
+        setWorkspaceSyncOnboardingCompleted,
+        setUserGlobalLastSyncedAt,
+        setWorkspaceLastPullAt,
+        setWorkspaceLastPushAt
+    ]);
+    const applyWorkspaceSyncStateSnapshot = useCallback((nextState) => {
+        const enabled = Boolean(nextState.cloudSyncEnabled);
+        setWorkspaceCloudSyncEnabled(enabled);
+        const source = nextState.sourceOfTruth === 'cloud' || nextState.sourceOfTruth === 'local'
+            ? nextState.sourceOfTruth
+            : null;
+        setWorkspaceSyncSourceOfTruth(source);
+        setWorkspaceSyncOnboardingCompleted(Boolean(nextState.onboardingCompleted));
+        if (typeof nextState.pullCursor === 'string') {
+            const trimmed = nextState.pullCursor.trim();
+            workspacePullCursorRef.current = trimmed.length > 0 ? trimmed : null;
+        }
+        else if (nextState.pullCursor === null) {
+            workspacePullCursorRef.current = null;
+        }
+    }, [
+        setWorkspaceCloudSyncEnabled,
+        setWorkspaceSyncSourceOfTruth,
+        setWorkspaceSyncOnboardingCompleted
+    ]);
+    const saveWorkspaceCloudSyncSettings = useCallback(async (nextState, deps) => {
+        if (!isValidWorkspaceKey(currentWorkspaceId)) {
+            return { success: false, error: 'Workspace setup is required before enabling sync.' };
+        }
+        const nextEnabled = Boolean(nextState.enabled);
+        const nextSource = nextState.sourceOfTruth === 'cloud' || nextState.sourceOfTruth === 'local'
+            ? nextState.sourceOfTruth
+            : null;
+        let resolvedSource = nextSource;
+        // I6: when enabling sync, always start with onboardingCompleted=false so the
+        // orchestrator can verify the first pull succeeds before marking it complete.
+        // When disabling, preserve whatever the caller passes (usually the current value).
+        const nextOnboardingCompleted = nextEnabled ? false : Boolean(nextState.onboardingCompleted);
+        try {
+            if (nextEnabled) {
+                if (!deps.isAuthenticated) {
+                    return { success: false, error: 'Sign in is required before enabling workspace sync.' };
+                }
+                if (!deps.cloudAuthConfigured) {
+                    return { success: false, error: 'Cloud authentication endpoint is not configured.' };
+                }
+                const ensured = await deps.ensureCloudWorkspaceReadyForSync();
+                if (!ensured.success) {
+                    return { success: false, error: ensured.error || 'Workspace sync handshake failed.' };
+                }
+                const shouldBootstrapLocal = nextSource === 'local'
+                    || (nextSource === null && ensured.provisioned === true);
+                if (resolvedSource === null) {
+                    resolvedSource = shouldBootstrapLocal ? 'local' : 'cloud';
+                }
+                if (shouldBootstrapLocal) {
+                    const snapshot = await deps.fetchLocalWorkspaceSnapshot();
+                    if (snapshot.error) {
+                        return { success: false, error: snapshot.error };
+                    }
+                    const [taxonomiesRes, documentsRes] = await Promise.allSettled([
+                        fetch('/api/taskforce/taxonomies', { method: 'GET', credentials: 'include' })
+                            .then((r) => r.ok
+                            ? r.json().catch(() => ({}))
+                            : Promise.resolve({}))
+                            .catch(() => ({})),
+                        fetch('/api/taskforce/sync/workspace/documents', { method: 'GET', credentials: 'include' })
+                            .then((r) => r.ok
+                            ? r.json().catch(() => ({}))
+                            : Promise.resolve({}))
+                            .catch(() => ({}))
+                    ]);
+                    const taxonomies = taxonomiesRes.status === 'fulfilled' && Array.isArray(taxonomiesRes.value?.taxonomies)
+                        ? taxonomiesRes.value.taxonomies
+                        : undefined;
+                    const documents = documentsRes.status === 'fulfilled' && Array.isArray(documentsRes.value?.documents)
+                        ? documentsRes.value.documents
+                            .filter((doc) => {
+                            if (!doc || typeof doc !== 'object')
+                                return false;
+                            const candidate = doc;
+                            return typeof candidate.path === 'string'
+                                && typeof candidate.updatedAt === 'string'
+                                && typeof candidate.content === 'string';
+                        })
+                        : undefined;
+                    const bootstrapRes = await bootstrapPushWorkspaceSnapshot(deps.resolveCloudAuthUrl, {
+                        workspaceId: currentWorkspaceId,
+                        tasks: snapshot.tasks,
+                        archived: snapshot.archived,
+                        taxonomies,
+                        documents
+                    });
+                    if (!bootstrapRes.ok) {
+                        const data = (bootstrapRes.data && typeof bootstrapRes.data === 'object')
+                            ? bootstrapRes.data
+                            : {};
+                        return {
+                            success: false,
+                            error: String(data.error || `Workspace bootstrap push failed (${bootstrapRes.status})`)
+                        };
+                    }
+                }
+            }
+            await persistWorkspaceSyncPatch({
+                cloudSyncEnabled: nextEnabled,
+                sourceOfTruth: resolvedSource,
+                onboardingCompleted: nextOnboardingCompleted
+            });
+            setWorkspaceCloudSyncEnabled(nextEnabled);
+            setWorkspaceSyncSourceOfTruth(resolvedSource);
+            setWorkspaceSyncOnboardingCompleted(nextOnboardingCompleted);
+            return { success: true };
+        }
+        catch {
+            return { success: false, error: 'Failed to save workspace sync settings.' };
+        }
+    }, [
+        setWorkspaceCloudSyncEnabled,
+        setWorkspaceSyncSourceOfTruth,
+        setWorkspaceSyncOnboardingCompleted,
+        persistWorkspaceSyncPatch
+    ]);
+    useEffect(() => {
+        workspaceLastPushedSignatureRef.current = '';
+        workspacePendingSignatureRef.current = '';
+        workspaceLastPushedTaskIdsRef.current = new Set();
+        workspaceDeletedTaskIdsRef.current = new Set();
+        workspacePullCursorRef.current = null;
+        workspacePullBootstrapDoneRef.current = false;
+        workspaceSyncStateReadCountRef.current = 0;
+        workspaceBackfillForcedRef.current.delete(currentWorkspaceId);
+        workspaceSyncReadyRef.current.delete(currentWorkspaceId);
+        workspaceCloudHydratedRef.current.delete(currentWorkspaceId);
+        workspaceRetryAttemptRef.current = 0;
+        workspaceRetryAtMsRef.current = null;
+        workspacePushInFlightRef.current = false;
+        workspacePullInFlightRef.current = false;
+        setWorkspaceSyncReady(false);
+        setWorkspaceCloudHydrated(false);
+        setWorkspaceSyncFailureCount(0);
+        setWorkspaceSyncRetryScheduledCount(0);
+        setWorkspaceSyncAuthFailureCount(0);
+        setWorkspaceSyncLastFailureSource(null);
+        setWorkspaceSyncLastFailureStatusCode(null);
+        setWorkspaceBootstrapSyncInProgress(false);
+        setWorkspaceBootstrapSyncPages(0);
+        setWorkspaceBootstrapSyncAppliedChanges(0);
+        if (workspaceRetryTimerRef.current !== null && typeof window !== 'undefined') {
+            window.clearTimeout(workspaceRetryTimerRef.current);
+            workspaceRetryTimerRef.current = null;
+        }
+        if (activeLockAbortControllerRef.current) {
+            activeLockAbortControllerRef.current.abort();
+            activeLockAbortControllerRef.current = null;
+        }
+        activeLockWorkspaceIdRef.current = null;
+        setWorkspaceRetryAt(null);
+    }, [currentWorkspaceId, setWorkspaceSyncReady, setWorkspaceCloudHydrated]);
+    useEffect(() => {
+        return () => {
+            if (workspaceRetryTimerRef.current !== null && typeof window !== 'undefined') {
+                window.clearTimeout(workspaceRetryTimerRef.current);
+                workspaceRetryTimerRef.current = null;
+            }
+            if (activeLockAbortControllerRef.current) {
+                activeLockAbortControllerRef.current.abort();
+                activeLockAbortControllerRef.current = null;
+            }
+            activeLockWorkspaceIdRef.current = null;
+        };
+    }, []);
+    return {
+        workspaceRetryAt,
+        setWorkspaceRetryAt,
+        isWorkspacePullRetryPending,
+        workspaceBootstrapSyncInProgress,
+        setWorkspaceBootstrapSyncInProgress,
+        workspaceBootstrapSyncPages,
+        setWorkspaceBootstrapSyncPages,
+        workspaceBootstrapSyncAppliedChanges,
+        setWorkspaceBootstrapSyncAppliedChanges,
+        workspaceSyncFailureCount,
+        workspaceSyncRetryScheduledCount,
+        workspaceSyncAuthFailureCount,
+        workspaceSyncLastFailureSource,
+        workspaceSyncLastFailureStatusCode,
+        workspacePushInFlightRef,
+        workspacePullInFlightRef,
+        workspaceLastPushedSignatureRef,
+        workspacePendingSignatureRef,
+        workspaceLastPushedTaskIdsRef,
+        workspaceDeletedTaskIdsRef,
+        workspacePullCursorRef,
+        workspacePullBootstrapDoneRef,
+        workspaceBackfillForcedRef,
+        workspaceSyncReadyRef,
+        workspaceCloudHydratedRef,
+        clearWorkspaceRetry,
+        scheduleWorkspacePullRetry,
+        isWorkspacePullCooldownActive,
+        markWorkspacePullCooldown,
+        tryAcquireWorkspacePullLease,
+        releaseWorkspacePullLease,
+        recordWorkspaceSyncFailure,
+        incrementWorkspaceSyncAuthFailure,
+        persistWorkspaceSyncPatch,
+        loadWorkspaceSyncState,
+        applyWorkspaceSyncStateSnapshot,
+        saveWorkspaceCloudSyncSettings
+    };
+}

package/dist/hooks/useWorkspaceSyncController.test.d.ts

@@ -0,0 +1 @@
+export {};