grepmax 0.26.72 → 0.26.74

package/dist/lib/daemon/watcher-manager.js

@@ -58,6 +58,7 @@ const walker_1 = require("../index/walker");
 const watcher_1 = require("../index/watcher");
 const watcher_errors_1 = require("../index/watcher-errors");
 const watcher_ignore_1 = require("../index/watcher-ignore");
+const watcher_recovery_1 = require("../index/watcher-recovery");
 const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
 const project_registry_1 = require("../utils/project-registry");
@@ -97,6 +98,14 @@ function abortableDelay(ms, signal) {
  * thin watchProject/unwatchProject delegators over this manager.
  */
 class WatcherManager {
+    recovery(root) {
+        let tracker = this.recoveryStates.get(root);
+        if (!tracker) {
+            tracker = new watcher_recovery_1.WatcherRecoveryTracker();
+            this.recoveryStates.set(root, tracker);
+        }
+        return tracker;
+    }
     constructor(deps) {
         this.deps = deps;
         this.pendingOps = new Set();
@@ -117,14 +126,15 @@ class WatcherManager {
         this.degradedRoots = new Set();
         this.terminalFailures = new Map();
         this.watchLifecycles = new Map();
+        this.recoveryStates = new Map();
         this.subscriptionUpdates = new Map();
         this.watcherGenerations = new Map();
     }
     health(root) {
-        var _a;
-        var _b, _c;
+        var _a, _b;
+        var _c, _d;
         return {
-            failedFiles: (_b = (_a = this.terminalFailures.get(root)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0,
+            failedFiles: (_c = (_a = this.terminalFailures.get(root)) === null || _a === void 0 ? void 0 : _a.size) !== null && _c !== void 0 ? _c : 0,
             degraded: this.isRootDegraded(root),
             watcherMode: this.pollIntervals.has(root)
                 ? "polling"
@@ -135,8 +145,9 @@ class WatcherManager {
                     : "native",
             catchupRunning: this.catchups.has(root),
             lastReconciledAt: this.reconciledAt.get(root),
-            overflowCount: (_c = this.overflowCounts.get(root)) !== null && _c !== void 0 ? _c : 0,
+            overflowCount: (_d = this.overflowCounts.get(root)) !== null && _d !== void 0 ? _d : 0,
             catchupMs: this.catchupDurations.get(root),
+            watcherRecovery: (_b = this.recoveryStates.get(root)) === null || _b === void 0 ? void 0 : _b.snapshot(),
         };
     }
     watchProject(root_1) {
@@ -325,8 +336,9 @@ class WatcherManager {
                 }
                 catch (_c) { }
                 this.deps.subscriptions.delete(root);
+                this.recovery(root).detached();
             }
-            const { subscription: sub } = yield (0, watcher_ignore_1.subscribeWithNativeExclusions)(root, (err, events) => {
+            const { subscription: sub, policy } = yield (0, watcher_ignore_1.subscribeWithNativeExclusions)(root, (err, events) => {
                 var _a, _b;
                 var _c, _d;
                 if (this.deps.processors.get(root) !== processor ||
@@ -334,6 +346,7 @@ class WatcherManager {
                     ((_b = (_a = this.deps).getShuttingDown) === null || _b === void 0 ? void 0 : _b.call(_a)))
                     return;
                 if (err) {
+                    this.recovery(root).error(err);
                     this.overflowCounts.set(root, ((_c = this.overflowCounts.get(root)) !== null && _c !== void 0 ? _c : 0) + 1);
                     const now = Date.now();
                     if (!this.lastWatcherErrorLogMs.has(root) ||
@@ -366,6 +379,7 @@ class WatcherManager {
                 return;
             }
             this.deps.subscriptions.set(root, sub);
+            this.recovery(root).attached(policy);
         });
     }
     requestOverflowCatchup(root, processor) {
@@ -409,6 +423,7 @@ class WatcherManager {
             if (sub) {
                 sub.unsubscribe().catch(() => { });
                 this.deps.subscriptions.delete(root);
+                this.recovery(root).detached();
             }
             if (!this.pollIntervals.has(root)) {
                 console.error(`[daemon:${name}] Native watcher failed after ${fails} terminal errors — switching to poll mode (${POLL_INTERVAL_MS / 60000}min interval)`);
@@ -583,186 +598,199 @@ class WatcherManager {
             var _a, e_1, _b, _c;
             var _d;
             var _e, _f, _g;
-            const scanStart = Date.now();
-            const overflowCountAtStart = (_e = this.overflowCounts.get(root)) !== null && _e !== void 0 ? _e : 0;
-            const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
-            const metaCache = this.deps.getMetaCache();
-            const vectorDb = this.deps.getVectorDb();
-            processor.filePolicy.invalidateIgnoreCache();
-            const rootPrefix = root.endsWith("/") ? root : `${root}/`;
-            const cachedPaths = yield metaCache.getKeysWithPrefix(rootPrefix);
-            const vectorPaths = yield vectorDb.getDistinctPathsForPrefix(rootPrefix);
-            const knownPaths = new Set([...cachedPaths, ...vectorPaths]);
-            if (signal.aborted)
-                return false;
-            const seenPaths = new Set();
-            const walkState = (0, walker_1.createWalkState)();
-            let queued = 0;
-            let skipped = 0;
-            let debugSamples = 0;
+            const tracker = this.recovery(root);
+            const scan = tracker.beginScan();
+            let outcome = "failed";
             try {
-                for (var _h = true, _j = __asyncValues((0, walker_1.walk)(root, {
-                    policy: processor.filePolicy,
-                    state: walkState,
-                })), _k; _k = yield _j.next(), _a = _k.done, !_a; _h = true) {
-                    _c = _k.value;
-                    _h = false;
-                    const relPath = _c;
-                    if (signal.aborted)
-                        return false;
-                    const absPath = path.join(root, relPath);
-                    try {
-                        const classification = yield processor.filePolicy.classifyFile(absPath);
-                        if (classification.status === "error") {
-                            walkState.protectedPaths.add(classification.protectedPath);
-                            walkState.errors.push({
-                                path: classification.protectedPath,
-                                error: classification.error,
-                            });
-                            continue;
-                        }
-                        if (classification.status !== "indexable")
-                            continue;
-                        const stats = classification.stat;
-                        seenPaths.add(absPath);
-                        let cached = metaCache.get(absPath);
-                        const reconciliation = (0, cache_coherence_1.reconcileMetaEntry)(absPath, cached, vectorPaths.has(absPath));
-                        if (reconciliation.action === "stamp") {
-                            cached = reconciliation.entry;
-                            metaCache.put(absPath, cached);
-                        }
-                        else if (reconciliation.action === "reprocess") {
-                            processor.handleFileEvent("change", absPath, {
-                                forceReprocess: true,
-                                workKind: "catchup",
-                            });
-                            queued++;
-                            if (queued % 500 === 0) {
-                                (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
-                                yield abortableDelay(5000, signal);
+                const scanStart = Date.now();
+                const overflowCountAtStart = (_e = this.overflowCounts.get(root)) !== null && _e !== void 0 ? _e : 0;
+                const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
+                const metaCache = this.deps.getMetaCache();
+                const vectorDb = this.deps.getVectorDb();
+                processor.filePolicy.invalidateIgnoreCache();
+                const rootPrefix = root.endsWith("/") ? root : `${root}/`;
+                const cachedPaths = yield metaCache.getKeysWithPrefix(rootPrefix);
+                const vectorPaths = yield vectorDb.getDistinctPathsForPrefix(rootPrefix);
+                const knownPaths = new Set([...cachedPaths, ...vectorPaths]);
+                if (signal.aborted)
+                    return false;
+                const seenPaths = new Set();
+                const walkState = (0, walker_1.createWalkState)();
+                let queued = 0;
+                let skipped = 0;
+                let debugSamples = 0;
+                try {
+                    for (var _h = true, _j = __asyncValues((0, walker_1.walk)(root, {
+                        policy: processor.filePolicy,
+                        state: walkState,
+                    })), _k; _k = yield _j.next(), _a = _k.done, !_a; _h = true) {
+                        _c = _k.value;
+                        _h = false;
+                        const relPath = _c;
+                        if (signal.aborted)
+                            return false;
+                        const absPath = path.join(root, relPath);
+                        try {
+                            const classification = yield processor.filePolicy.classifyFile(absPath);
+                            if (classification.status === "error") {
+                                walkState.protectedPaths.add(classification.protectedPath);
+                                walkState.errors.push({
+                                    path: classification.protectedPath,
+                                    error: classification.error,
+                                });
+                                continue;
                             }
-                            continue;
-                        }
-                        if (!isFileCached(cached, stats)) {
-                            // Fast path: if only mtime changed but size is identical and we have a hash,
-                            // just verify the hash in-process instead of sending to a worker.
-                            if ((cached === null || cached === void 0 ? void 0 : cached.hash) && cached.size === stats.size) {
-                                const observed = Object.assign({}, cached);
-                                const snapshot = yield (0, file_utils_1.readFileSnapshot)(absPath, {
-                                    projectRoot: root,
+                            if (classification.status !== "indexable")
+                                continue;
+                            const stats = classification.stat;
+                            seenPaths.add(absPath);
+                            let cached = metaCache.get(absPath);
+                            const reconciliation = (0, cache_coherence_1.reconcileMetaEntry)(absPath, cached, vectorPaths.has(absPath));
+                            if (reconciliation.action === "stamp") {
+                                cached = reconciliation.entry;
+                                metaCache.put(absPath, cached);
+                            }
+                            else if (reconciliation.action === "reprocess") {
+                                processor.handleFileEvent("change", absPath, {
+                                    forceReprocess: true,
+                                    workKind: "catchup",
                                 });
-                                if (snapshot.size !== stats.size ||
-                                    snapshot.mtimeMs !== stats.mtimeMs) {
-                                    processor.handleFileEvent("change", absPath, {
-                                        workKind: "catchup",
-                                    });
-                                    continue;
+                                queued++;
+                                if (queued % 500 === 0) {
+                                    (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
+                                    yield abortableDelay(5000, signal);
                                 }
-                                const hash = (0, file_utils_1.computeContentHash)(snapshot.buffer, absPath);
-                                if (hash === observed.hash) {
-                                    // Content unchanged — update mtime in cache and skip worker
-                                    if (signal.aborted)
-                                        return false;
-                                    // A live batch can finish while this read yields. Never replace
-                                    // newer metadata or resurrect a cache entry it removed.
-                                    const current = metaCache.get(absPath);
-                                    if (current &&
-                                        current.hash === observed.hash &&
-                                        current.mtimeMs === observed.mtimeMs &&
-                                        current.size === observed.size &&
-                                        current.hashVersion === observed.hashVersion &&
-                                        current.hasVectors === observed.hasVectors) {
-                                        metaCache.put(absPath, Object.assign(Object.assign({}, observed), { mtimeMs: stats.mtimeMs }));
+                                continue;
+                            }
+                            if (!isFileCached(cached, stats)) {
+                                // Fast path: if only mtime changed but size is identical and we have a hash,
+                                // just verify the hash in-process instead of sending to a worker.
+                                if ((cached === null || cached === void 0 ? void 0 : cached.hash) && cached.size === stats.size) {
+                                    const observed = Object.assign({}, cached);
+                                    const snapshot = yield (0, file_utils_1.readFileSnapshot)(absPath, {
+                                        projectRoot: root,
+                                    });
+                                    if (snapshot.size !== stats.size ||
+                                        snapshot.mtimeMs !== stats.mtimeMs) {
+                                        processor.handleFileEvent("change", absPath, {
+                                            workKind: "catchup",
+                                        });
+                                        continue;
+                                    }
+                                    const hash = (0, file_utils_1.computeContentHash)(snapshot.buffer, absPath);
+                                    if (hash === observed.hash) {
+                                        // Content unchanged — update mtime in cache and skip worker
+                                        if (signal.aborted)
+                                            return false;
+                                        // A live batch can finish while this read yields. Never replace
+                                        // newer metadata or resurrect a cache entry it removed.
+                                        const current = metaCache.get(absPath);
+                                        if (current &&
+                                            current.hash === observed.hash &&
+                                            current.mtimeMs === observed.mtimeMs &&
+                                            current.size === observed.size &&
+                                            current.hashVersion === observed.hashVersion &&
+                                            current.hasVectors === observed.hasVectors) {
+                                            metaCache.put(absPath, Object.assign(Object.assign({}, observed), { mtimeMs: stats.mtimeMs }));
+                                        }
+                                        skipped++;
+                                        continue;
                                     }
-                                    skipped++;
-                                    continue;
+                                }
+                                // Debug: log first few misses to diagnose re-queue loops
+                                if (debugSamples < 5) {
+                                    (0, logger_1.debug)("catchup", `miss ${relPath}: cached=${cached ? `mtime=${Math.trunc(cached.mtimeMs)} size=${cached.size}` : "null"} stat=mtime=${Math.trunc(stats.mtimeMs)} size=${stats.size}`);
+                                    debugSamples++;
+                                }
+                                if (signal.aborted)
+                                    return false;
+                                processor.handleFileEvent("change", absPath, {
+                                    workKind: "catchup",
+                                });
+                                queued++;
+                                // Throttle: pause periodically during large catchup scans to let the
+                                // batch processor drain and compaction run between bursts.
+                                if (queued % 500 === 0) {
+                                    (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
+                                    yield abortableDelay(5000, signal);
                                 }
                             }
-                            // Debug: log first few misses to diagnose re-queue loops
-                            if (debugSamples < 5) {
-                                (0, logger_1.debug)("catchup", `miss ${relPath}: cached=${cached ? `mtime=${Math.trunc(cached.mtimeMs)} size=${cached.size}` : "null"} stat=mtime=${Math.trunc(stats.mtimeMs)} size=${stats.size}`);
-                                debugSamples++;
-                            }
-                            if (signal.aborted)
-                                return false;
-                            processor.handleFileEvent("change", absPath, { workKind: "catchup" });
-                            queued++;
-                            // Throttle: pause periodically during large catchup scans to let the
-                            // batch processor drain and compaction run between bursts.
-                            if (queued % 500 === 0) {
-                                (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
-                                yield abortableDelay(5000, signal);
+                            else {
+                                skipped++;
                             }
                         }
-                        else {
-                            skipped++;
+                        catch (error) {
+                            walkState.protectedPaths.add(absPath);
+                            walkState.errors.push({ path: absPath, error });
                         }
                     }
-                    catch (error) {
-                        walkState.protectedPaths.add(absPath);
-                        walkState.errors.push({ path: absPath, error });
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_h && !_a && (_b = _j.return)) yield _b.call(_j);
                     }
+                    finally { if (e_1) throw e_1.error; }
                 }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_h && !_a && (_b = _j.return)) yield _b.call(_j);
+                (0, logger_1.debug)("catchup", `${path.basename(root)}: ${queued} queued, ${skipped} skipped (cached ok), ${seenPaths.size} total`);
+                // Purge files deleted while daemon was offline
+                let purged = 0;
+                for (const cachedPath of knownPaths) {
+                    if (signal.aborted)
+                        return false;
+                    if (!seenPaths.has(cachedPath) &&
+                        !(0, walker_1.isPathProtectedByWalkState)(cachedPath, walkState)) {
+                        processor.handleFileEvent("unlink", cachedPath, {
+                            forceDelete: true,
+                            workKind: "cleanup",
+                        });
+                        purged++;
+                    }
                 }
-                finally { if (e_1) throw e_1.error; }
-            }
-            (0, logger_1.debug)("catchup", `${path.basename(root)}: ${queued} queued, ${skipped} skipped (cached ok), ${seenPaths.size} total`);
-            // Purge files deleted while daemon was offline
-            let purged = 0;
-            for (const cachedPath of knownPaths) {
-                if (signal.aborted)
-                    return false;
-                if (!seenPaths.has(cachedPath) &&
-                    !(0, walker_1.isPathProtectedByWalkState)(cachedPath, walkState)) {
-                    processor.handleFileEvent("unlink", cachedPath, {
-                        forceDelete: true,
-                        workKind: "cleanup",
+                const complete = walkState.rootComplete && walkState.errors.length === 0;
+                if (!complete) {
+                    this.degradedRoots.add(root);
+                    (0, watcher_store_1.registerWatcher)({
+                        pid: process.pid,
+                        projectRoot: root,
+                        startTime: Date.now(),
+                        status: "degraded",
+                        lastHeartbeat: Date.now(),
+                        lastError: `${walkState.errors.length} scan path(s) incomplete`,
                     });
-                    purged++;
                 }
+                else {
+                    this.degradedRoots.delete(root);
+                    const failedFiles = (_f = (_d = this.terminalFailures.get(root)) === null || _d === void 0 ? void 0 : _d.size) !== null && _f !== void 0 ? _f : 0;
+                    (0, watcher_store_1.registerWatcher)(Object.assign({ pid: process.pid, projectRoot: root, startTime: Date.now(), status: this.isRootDegraded(root) ? "degraded" : "watching", lastHeartbeat: Date.now() }, (failedFiles > 0
+                        ? {
+                            lastError: `${failedFiles} file(s) exhausted automatic retries`,
+                        }
+                        : {})));
+                }
+                if (queued > 0 || purged > 0) {
+                    const parts = [];
+                    if (queued > 0)
+                        parts.push(`${queued} changed`);
+                    if (purged > 0)
+                        parts.push(`${purged} deleted`);
+                    console.log(`[daemon:${path.basename(root)}] Catchup: ${parts.join(", ")} file(s) while offline`);
+                }
+                const ended = Date.now();
+                this.lastCatchupEndMs.set(root, ended);
+                this.catchupDurations.set(root, ended - scanStart);
+                if (complete) {
+                    this.reconciledAt.set(root, ended);
+                    // A later gap still needs its deferred scan, even if this walk succeeded.
+                    if (((_g = this.overflowCounts.get(root)) !== null && _g !== void 0 ? _g : 0) === overflowCountAtStart)
+                        this.overflowPendingRoots.delete(root);
+                }
+                outcome = complete ? "complete" : "incomplete";
+                return complete;
             }
-            const complete = walkState.rootComplete && walkState.errors.length === 0;
-            if (!complete) {
-                this.degradedRoots.add(root);
-                (0, watcher_store_1.registerWatcher)({
-                    pid: process.pid,
-                    projectRoot: root,
-                    startTime: Date.now(),
-                    status: "degraded",
-                    lastHeartbeat: Date.now(),
-                    lastError: `${walkState.errors.length} scan path(s) incomplete`,
-                });
-            }
-            else {
-                this.degradedRoots.delete(root);
-                const failedFiles = (_f = (_d = this.terminalFailures.get(root)) === null || _d === void 0 ? void 0 : _d.size) !== null && _f !== void 0 ? _f : 0;
-                (0, watcher_store_1.registerWatcher)(Object.assign({ pid: process.pid, projectRoot: root, startTime: Date.now(), status: this.isRootDegraded(root) ? "degraded" : "watching", lastHeartbeat: Date.now() }, (failedFiles > 0
-                    ? { lastError: `${failedFiles} file(s) exhausted automatic retries` }
-                    : {})));
-            }
-            if (queued > 0 || purged > 0) {
-                const parts = [];
-                if (queued > 0)
-                    parts.push(`${queued} changed`);
-                if (purged > 0)
-                    parts.push(`${purged} deleted`);
-                console.log(`[daemon:${path.basename(root)}] Catchup: ${parts.join(", ")} file(s) while offline`);
-            }
-            const ended = Date.now();
-            this.lastCatchupEndMs.set(root, ended);
-            this.catchupDurations.set(root, ended - scanStart);
-            if (complete) {
-                this.reconciledAt.set(root, ended);
-                // A later gap still needs its deferred scan, even if this walk succeeded.
-                if (((_g = this.overflowCounts.get(root)) !== null && _g !== void 0 ? _g : 0) === overflowCountAtStart)
-                    this.overflowPendingRoots.delete(root);
+            finally {
+                tracker.finishScan(scan, signal.aborted ? "aborted" : outcome);
             }
-            return complete;
         });
     }
     runCatchup(root, processor) {
@@ -792,9 +820,19 @@ class WatcherManager {
                 }
             } while (active.dirty && !signal.aborted);
         });
-        const run = (this.deps.runProjectOperation
-            ? this.deps.runProjectOperation(root, "watch-catchup", active.controller.signal, execute)
-            : execute(active.controller.signal)).finally(() => {
+        const tracker = this.recovery(root);
+        const scansBeforeAttempt = tracker.snapshot().scanCount;
+        const run = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield (this.deps.runProjectOperation
+                    ? this.deps.runProjectOperation(root, "watch-catchup", active.controller.signal, execute)
+                    : execute(active.controller.signal));
+            }
+            catch (error) {
+                tracker.attemptFailed(tracker.snapshot().scanCount > scansBeforeAttempt, active.controller.signal.aborted);
+                throw error;
+            }
+        }))().finally(() => {
             if (this.catchups.get(root) === active)
                 this.catchups.delete(root);
         });
@@ -855,6 +893,7 @@ class WatcherManager {
             this.overflowPendingRoots.delete(root);
             this.degradedRoots.delete(root);
             this.terminalFailures.delete(root);
+            this.recoveryStates.delete(root);
             (0, watcher_store_1.unregisterWatcherByRoot)(root);
             console.log(`[daemon] Unwatched ${root}`);
         });

package/dist/lib/index/watcher-recovery.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatcherRecoveryTracker = void 0;
+const node_crypto_1 = require("node:crypto");
+const watcher_errors_1 = require("./watcher-errors");
+/** Fixed-size, process/lifecycle-local evidence. A completed walk covers only
+ * errors already observed when it began; queued ingestion is reported separately. */
+class WatcherRecoveryTracker {
+    constructor() {
+        this.gapCount = 0;
+        this.terminalErrorCount = 0;
+        this.coveredGapCount = 0;
+        this.coveredTerminalErrorCount = 0;
+        this.scanCount = 0;
+        this.scanIncomplete = false;
+    }
+    error(error) {
+        if ((0, watcher_errors_1.isFSEventsGap)(error)) {
+            this.gapCount++;
+            this.lastGapAt = Date.now();
+        }
+        else {
+            this.terminalErrorCount++;
+            this.lastTerminalErrorAt = Date.now();
+        }
+    }
+    beginScan() {
+        const scan = {
+            id: ++this.scanCount,
+            startedAt: Date.now(),
+            gapCountAtStart: this.gapCount,
+            terminalErrorCountAtStart: this.terminalErrorCount,
+            outcome: "running",
+        };
+        this.lastScan = scan;
+        return scan;
+    }
+    finishScan(scan, outcome) {
+        scan.finishedAt = Date.now();
+        scan.outcome = outcome;
+        if (outcome === "complete") {
+            this.scanIncomplete = false;
+            this.coveredGapCount = Math.max(this.coveredGapCount, scan.gapCountAtStart);
+            this.coveredTerminalErrorCount = Math.max(this.coveredTerminalErrorCount, scan.terminalErrorCountAtStart);
+            this.lastCompleteScan = Object.assign({}, scan);
+        }
+        else
+            this.scanIncomplete = true;
+    }
+    attemptFailed(scanStarted, aborted) {
+        this.scanIncomplete = true;
+        this.lastAttemptFailure = { at: Date.now(), scanStarted, aborted };
+    }
+    attached(policy) {
+        // The subscription helper returns the exact accepted policy, including its
+        // fallback. Summarize that value; never rediscover directories for health.
+        const patterns = JSON.parse(policy);
+        const literalCount = patterns.filter((pattern) => !pattern.startsWith("/") && !pattern.includes("*")).length;
+        this.exclusions = {
+            attached: true,
+            literalCount,
+            filterCount: patterns.length - literalCount,
+            fingerprint: (0, node_crypto_1.createHash)("sha256").update(policy).digest("hex"),
+        };
+    }
+    detached() {
+        if (this.exclusions)
+            this.exclusions.attached = false;
+    }
+    snapshot() {
+        var _a;
+        return {
+            gapCount: this.gapCount,
+            terminalErrorCount: this.terminalErrorCount,
+            coveredGapCount: this.coveredGapCount,
+            outstandingGapCount: this.gapCount - this.coveredGapCount,
+            reconciliationNeeded: this.scanIncomplete ||
+                ((_a = this.lastScan) === null || _a === void 0 ? void 0 : _a.outcome) === "running" ||
+                this.gapCount > this.coveredGapCount ||
+                this.terminalErrorCount > this.coveredTerminalErrorCount,
+            lastGapAt: this.lastGapAt,
+            lastTerminalErrorAt: this.lastTerminalErrorAt,
+            scanCount: this.scanCount,
+            lastScan: this.lastScan && Object.assign({}, this.lastScan),
+            lastCompleteScan: this.lastCompleteScan && Object.assign({}, this.lastCompleteScan),
+            lastAttemptFailure: this.lastAttemptFailure && Object.assign({}, this.lastAttemptFailure),
+            exclusions: this.exclusions && Object.assign({}, this.exclusions),
+        };
+    }
+}
+exports.WatcherRecoveryTracker = WatcherRecoveryTracker;