@solncebro/market-data-feeder-lib 0.1.0

package/dist/source/marketDataManager.js

@@ -0,0 +1,930 @@
+import { EventEmitter } from 'node:events';
+import { MarketTypeEnum, RateLimitedRequestQueue, TradifiSymbolGate, logger } from '@solncebro/trade-engine';
+import { KLINE_BUFFER_SIZE, STALENESS_THRESHOLD_MULTIPLIER, resolveIntervalMs } from '../domain/constants.js';
+import { calculateAllMaValues } from './indicators.js';
+import { crossesMassStaleThreshold } from './massStale.js';
+import { computeSymbolListDelta } from './symbolListDelta.js';
+import { evaluateSymbolRemovalList } from './symbolRemovalGuard.js';
+import { mergeRepairedKlines } from './gapRepair.js';
+import { withTimeout } from '../utils/timeout.js';
+import { startIntervalScheduler } from '../utils/intervalScheduler.js';
+const KLINE_UPDATE_THROTTLE_MS = 5000;
+const STALENESS_CHECK_INTERVAL_MS = 60_000;
+const STALENESS_HEARTBEAT_EVERY_N_TICKS = 15;
+const LOAD_KLINES_TIMEOUT_MS = 60_000;
+const PERSISTENT_STALE_THRESHOLD_TICK_COUNT = 10;
+const KLINE_LOAD_PROGRESS_LOG_EVERY = 100;
+const SILENCE_CHECK_INTERVAL_MS = 10_000;
+const SILENCE_THRESHOLD_MS = 45_000;
+const VOLUME_REFRESH_INTERVAL_MS = 30_000;
+const MASS_STALE_RATIO_THRESHOLD = 0.3;
+const MASS_STALE_MIN_SYMBOLS = 20;
+// Gap repair: a candle missed by the stream (or sealed locally without the exchange's closing
+// frame) is healed by a REST refetch merged into the buffer, then pushed to clients as a reseed.
+// The per-symbol cooldown bounds the REST cost of sparse symbols whose "gaps" are legit (the
+// exchange never created the candle), and the concurrency cap keeps a mass-gap avalanche after a
+// transport blip from monopolizing the shared backfill pacer.
+const GAP_REPAIR_COOLDOWN_MS = 600_000;
+const MAX_CONCURRENT_GAP_REPAIRS = 3;
+const GAP_REPAIR_BASE_FETCH_COUNT = 2;
+// A symbol whose buffer sits far below the history its listing time implies (a truncated REST load —
+// the exchange momentarily served a few candles instead of the full window) is re-backfilled through
+// the gap-repair queue until it fills, without waiting for a full process restart. The tolerance
+// absorbs the newest forming/edge candles so a healthy, fully-loaded symbol is never flagged.
+const UNDERGROWN_TOLERANCE = 3;
+// A latched (converged) symbol is still re-probed at a slow cadence: the exchange's "no more
+// candles" answer may itself have been a persistent transient, and an hourly full-window probe
+// heals it within the hour instead of never.
+const CONVERGED_REPROBE_INTERVAL_MS = 3_600_000;
+// After this many CONSECUTIVE hourly re-probes reconfirm the convergence, the exchange's answer is
+// accepted as the symbol's true history start: a contract that started trading later than its
+// listing time is the norm (Bybit announces ~a day ahead), not an anomaly to alarm on for weeks —
+// the symbol leaves the digest and is measured from its own first candle from then on.
+const CONVERGED_ACCEPT_REPROBE_COUNT = 2;
+// Fallback pacer for the no-arg constructor (tests). Production injects an exchange-tuned queue from
+// feeder.ts (resolveBackfillRequestsPerSecond) — Binance must run slower than this to stay under its
+// per-IP REQUEST_WEIGHT budget.
+const KLINE_BACKFILL_REQUESTS_PER_SECOND = 80;
+const DEFAULT_BACKFILL_QUEUE = new RateLimitedRequestQueue({
+    rateLimit: KLINE_BACKFILL_REQUESTS_PER_SECOND,
+    intervalMs: 1000,
+    loggerLabel: '[MarketData:backfill]',
+});
+const ZERO_MA = { ma25: 0, ma50: 0, ma100: 0, ma200: 0 };
+export function markBackfilledHistoryClosed(klineList) {
+    for (let index = 0; index < klineList.length - 1; index++) {
+        if (klineList[index].isClosed !== true) {
+            klineList[index].isClosed = true;
+        }
+    }
+}
+class MarketDataManager extends EventEmitter {
+    exchangeConnector;
+    tradifiSymbolGate;
+    interval;
+    klineListBySymbol = new Map();
+    maValuesBySymbol = new Map();
+    subscriptionBySymbol = new Map();
+    handlerBySymbol = new Map();
+    currentKlineBySymbol = new Map();
+    lastEmittedUpdateBySymbol = new Map();
+    consecutiveStaleScanCountBySymbol = new Map();
+    persistentStaleEmittedSet = new Set();
+    skippedOlderKlineCountBySymbol = new Map();
+    throttledMaRecomputeCount = 0;
+    skippedStaleEmitCount = 0;
+    lastInboundAtMs = 0;
+    isStreamSilent = false;
+    isMassStale = false;
+    isShutDown = false;
+    pendingRemovalSet = new Set();
+    isSymbolSyncAnomalyActive = false;
+    lastGapRepairAtMsBySymbol = new Map();
+    gapRepairInFlightSet = new Set();
+    gapRepairPendingSymbolList = [];
+    gapRepairFetchCountBySymbol = new Map();
+    // Symbols whose backfill has converged — a refetch returned data but added nothing while the buffer
+    // is still below the expected size (the exchange genuinely serves fewer candles than the listing
+    // time implies, e.g. a contract announced long before its first candle). Re-scheduling stops until
+    // the buffer changes, so a symbol with a short real history does not retry forever.
+    backfillConvergedSet = new Set();
+    // First converged measurement (the pending vote). The latch requires TWO full-window convergences
+    // in a row: the incident this machinery exists for IS a transient full-window truncation, so a
+    // single measurement must never disable the backfill (mirrors the mass-removal
+    // confirm-on-second-sync guard). Any merge that adds data clears the vote.
+    pendingBackfillConvergeSet = new Set();
+    // Consecutive hourly re-probes that reconfirmed a latched convergence; at
+    // CONVERGED_ACCEPT_REPROBE_COUNT the short history is accepted as the exchange's truth.
+    convergedReprobeCountBySymbol = new Map();
+    // Exchange-confirmed history start (the oldest candle of a repeatedly reconfirmed short history).
+    // Overrides the listing time in the expectation so an accepted symbol reads healthy.
+    acceptedHistoryStartMsBySymbol = new Map();
+    locallyClosedCandleCount = 0;
+    stalenessSchedulerHandle = null;
+    silenceSchedulerHandle = null;
+    volumeSchedulerHandle = null;
+    lastEmittedVolumeBySymbol = new Map();
+    backfillQueue;
+    constructor(exchangeConnector, interval, backfillQueue = DEFAULT_BACKFILL_QUEUE) {
+        super();
+        this.exchangeConnector = exchangeConnector;
+        this.tradifiSymbolGate = new TradifiSymbolGate({ connector: exchangeConnector });
+        this.interval = interval;
+        this.backfillQueue = backfillQueue;
+    }
+    start() {
+        this.startStalenessWatchdog();
+        this.startSilenceWatchdog();
+        this.startVolumeRefreshScheduler();
+    }
+    async loadAllSymbols() {
+        const allSymbolList = await this.tradifiSymbolGate.loadUniverse();
+        // Teardown can land at any await of this method (the registry defers it until the load settles,
+        // but the source may also be shut down directly) — from here on every stage bails out on
+        // isShutDown so a dead source never enqueues backfill work or subscribes exchange streams.
+        if (this.isShutDown) {
+            logger.warn({}, `[MarketData] loadAllSymbols aborted — source shut down during the symbol-list fetch [${this.interval}]`);
+            return;
+        }
+        const usdtSymbolList = allSymbolList.filter((symbol) => symbol.endsWith('USDT'));
+        logger.info({ symbolCount: usdtSymbolList.length, filtered: allSymbolList.length - usdtSymbolList.length }, `[MarketData] Starting kline loading: ${usdtSymbolList.length} USDT symbols [${this.interval}]`);
+        this.emit('intervalLoadStarted', usdtSymbolList.length);
+        await this.loadKlines(usdtSymbolList);
+        if (this.isShutDown) {
+            logger.warn({ requestedCount: usdtSymbolList.length }, `[MarketData] loadAllSymbols aborted — source shut down during backfill; skipping subscriptions and load accounting [${this.interval}]`);
+            return;
+        }
+        this.subscribeToKlines(usdtSymbolList);
+        const loadedCount = this.klineListBySymbol.size;
+        const failedSymbolList = usdtSymbolList.filter((symbol) => !this.klineListBySymbol.has(symbol));
+        for (const symbol of failedSymbolList) {
+            this.emit('symbolLoadFailed', symbol);
+        }
+        logger.info({ loadedCount, requestedCount: usdtSymbolList.length, failedCount: failedSymbolList.length }, `[MarketData] All klines loaded (${loadedCount}/${usdtSymbolList.length} symbols), subscriptions active [${this.interval}]`);
+        this.emit('intervalLoadCompleted', loadedCount);
+    }
+    getInterval() {
+        return this.interval;
+    }
+    getIntervalMs() {
+        return resolveIntervalMs(this.interval);
+    }
+    getMaValues(symbol) {
+        return this.maValuesBySymbol.get(symbol) ?? ZERO_MA;
+    }
+    getKlineList(symbol) {
+        return this.klineListBySymbol.get(symbol) ?? [];
+    }
+    getCurrentKline(symbol) {
+        return this.currentKlineBySymbol.get(symbol);
+    }
+    getSymbolList() {
+        return Array.from(this.klineListBySymbol.keys());
+    }
+    getKlineCount() {
+        let total = 0;
+        for (const klineList of this.klineListBySymbol.values()) {
+            total += klineList.length;
+        }
+        return total;
+    }
+    getLastUpdateTimestamp(symbol) {
+        return this.lastEmittedUpdateBySymbol.get(symbol)?.emittedAtMs;
+    }
+    getLastKlineOpenTimestamp(symbol) {
+        const klineList = this.klineListBySymbol.get(symbol);
+        if (klineList === undefined || klineList.length === 0) {
+            return undefined;
+        }
+        return klineList[klineList.length - 1].openTimestamp;
+    }
+    getVolume24h(symbol) {
+        const ticker = this.exchangeConnector.getTicker(symbol, MarketTypeEnum.Futures);
+        return ticker?.quoteVolume ?? Number.POSITIVE_INFINITY;
+    }
+    getSubscriptionCount() {
+        return this.subscriptionBySymbol.size;
+    }
+    getStreamLiveness() {
+        const silenceMs = this.lastInboundAtMs > 0 ? Date.now() - this.lastInboundAtMs : 0;
+        return { lastInboundAtMs: this.lastInboundAtMs, silenceMs, isStreamSilent: this.isStreamSilent };
+    }
+    getFreshSymbolCount() {
+        return this.klineListBySymbol.size - this.getStaleSymbolList().length;
+    }
+    getPersistentStaleCount() {
+        return this.consecutiveStaleScanCountBySymbol.size;
+    }
+    getStaleSymbolList() {
+        const intervalMs = resolveIntervalMs(this.interval);
+        const thresholdMs = STALENESS_THRESHOLD_MULTIPLIER * intervalMs;
+        const nowMs = Date.now();
+        const staleSymbolList = [];
+        for (const [symbol, klineList] of this.klineListBySymbol) {
+            if (klineList.length === 0) {
+                continue;
+            }
+            const lastKline = klineList[klineList.length - 1];
+            const referenceTimestamp = lastKline.closeTimestamp > 0 ? lastKline.closeTimestamp : lastKline.openTimestamp + intervalMs;
+            const ageMs = nowMs - referenceTimestamp;
+            if (ageMs > thresholdMs) {
+                staleSymbolList.push({ symbol, ageMs });
+            }
+        }
+        staleSymbolList.sort((first, second) => second.ageMs - first.ageMs);
+        return staleSymbolList;
+    }
+    async ensureSymbolLoaded(symbol) {
+        if (this.klineListBySymbol.has(symbol)) {
+            return 'alreadyLoaded';
+        }
+        const exchangeClient = this.exchangeConnector.futures;
+        const exchangeSymbolList = await this.tradifiSymbolGate.loadUniverse();
+        // A non-empty exchange list that lacks the symbol = legit absence (delisted / never listed / a
+        // typo that passed the boundary pattern) — an empty snapshot is the correct answer, not an
+        // endless retry loop. An EMPTY list means the list read itself failed (getFuturesSymbols
+        // swallows errors into []) — fall through to the REST fetch, which reports its own failure.
+        if (exchangeSymbolList.length > 0 && !exchangeSymbolList.includes(symbol)) {
+            logger.warn({ symbol }, `[MarketData] ${symbol} is not on the exchange — skipping load [${this.interval}]`);
+            return 'notOnExchange';
+        }
+        logger.info({ symbol }, `[MarketData] ${symbol} ensureSymbolLoaded fetchKlines request limit=${KLINE_BUFFER_SIZE} [${this.interval}]`);
+        try {
+            const rawKlineList = await this.backfillQueue.execute(() => (this.isShutDown ? Promise.resolve([]) : this.fetchKlinesWithTimeout(exchangeClient.fetchKlines(symbol, this.interval, { limit: KLINE_BUFFER_SIZE }), LOAD_KLINES_TIMEOUT_MS, symbol)), `ensureSymbolLoaded ${symbol} [${this.interval}]`);
+            if (this.isShutDown) {
+                return 'aborted';
+            }
+            // The bulk load may have populated (and subscribed) this symbol while our fetch was queued
+            // behind the shared pacer — its live buffer wins over this stale copy.
+            if (this.klineListBySymbol.has(symbol)) {
+                return 'alreadyLoaded';
+            }
+            const klineList = rawKlineList.slice(-KLINE_BUFFER_SIZE);
+            logger.info({ symbol, klineCount: klineList.length }, `[MarketData] ${symbol} ensureSymbolLoaded fetchKlines response klineCount=${klineList.length} [${this.interval}]`);
+            // Listed but no candles yet (e.g. a contract published before trading starts): a legit
+            // absence, not a transient failure — throwing here would blank a whole multi-symbol scope
+            // into a 4001 retry loop because of one such symbol. The digest still hears about it.
+            if (klineList.length === 0) {
+                logger.warn({ symbol }, `[MarketData] ${symbol} ensureSymbolLoaded — empty kline history, skipping subscription [${this.interval}]`);
+                this.emit('symbolLoadFailed', symbol);
+                return 'noHistory';
+            }
+            markBackfilledHistoryClosed(klineList);
+            this.klineListBySymbol.set(symbol, klineList);
+            const lastKline = klineList[klineList.length - 1];
+            if (lastKline.isClosed !== true) {
+                this.currentKlineBySymbol.set(symbol, lastKline);
+            }
+            this.recalculateAndStoreMa(symbol, klineList);
+            this.subscribeToKlines([symbol]);
+            logger.info({ symbol }, `[MarketData] ${symbol} ensureSymbolLoaded — subscribed [${this.interval}]`);
+            this.emit('symbolLoadCompleted', symbol);
+            return 'loaded';
+        }
+        catch (error) {
+            logger.error({ symbol, error }, `[MarketData] ${symbol} ensureSymbolLoaded failed [${this.interval}]`);
+            this.emit('symbolLoadFailed', symbol);
+            throw error;
+        }
+    }
+    releaseSymbol(symbol) {
+        // Tell the health monitor the symbol's streams are gone for good (its digest keys can never
+        // recover), and pull it from the gap-repair queue so a released symbol does not burn a paced
+        // REST request on a buffer that no longer exists.
+        this.emit('symbolReleased', symbol);
+        const pendingRepairIndex = this.gapRepairPendingSymbolList.indexOf(symbol);
+        if (pendingRepairIndex !== -1) {
+            this.gapRepairPendingSymbolList.splice(pendingRepairIndex, 1);
+        }
+        const exchangeClient = this.exchangeConnector.futures;
+        const subscription = this.subscriptionBySymbol.get(symbol);
+        if (subscription !== undefined) {
+            try {
+                exchangeClient.unsubscribeKlines(subscription);
+            }
+            catch (error) {
+                logger.warn({ symbol, error }, `[MarketData] ${symbol} releaseSymbol — unsubscribeKlines failed (continuing cleanup) [${this.interval}]`);
+            }
+        }
+        this.subscriptionBySymbol.delete(symbol);
+        this.handlerBySymbol.delete(symbol);
+        this.klineListBySymbol.delete(symbol);
+        this.maValuesBySymbol.delete(symbol);
+        this.currentKlineBySymbol.delete(symbol);
+        this.lastEmittedUpdateBySymbol.delete(symbol);
+        this.consecutiveStaleScanCountBySymbol.delete(symbol);
+        this.persistentStaleEmittedSet.delete(symbol);
+        this.skippedOlderKlineCountBySymbol.delete(symbol);
+        this.lastEmittedVolumeBySymbol.delete(symbol);
+        this.lastGapRepairAtMsBySymbol.delete(symbol);
+        this.gapRepairFetchCountBySymbol.delete(symbol);
+        this.backfillConvergedSet.delete(symbol);
+        this.pendingBackfillConvergeSet.delete(symbol);
+        this.convergedReprobeCountBySymbol.delete(symbol);
+        this.acceptedHistoryStartMsBySymbol.delete(symbol);
+    }
+    async syncAllSymbols() {
+        try {
+            // reloadUniverse refreshes the exchange symbol cache first — without it the hourly sync
+            // compares the cached list against itself and can never see a listing or delisting.
+            const allSymbolList = await this.tradifiSymbolGate.reloadUniverse();
+            const usdtSymbolList = allSymbolList.filter((symbol) => symbol.endsWith('USDT'));
+            if (usdtSymbolList.length === 0) {
+                logger.warn({ loadedSymbolCount: this.klineListBySymbol.size }, `[MarketData] Symbol sync skipped — exchange returned an empty symbol list [${this.interval}]`);
+                return;
+            }
+            const loadedSymbolCount = this.klineListBySymbol.size;
+            const delta = computeSymbolListDelta({ loadedSymbolList: this.getSymbolList(), exchangeSymbolList: usdtSymbolList });
+            if (delta.addedSymbolList.length === 0 && delta.removedSymbolList.length === 0) {
+                this.pendingRemovalSet = new Set();
+                this.resolveSymbolSyncAnomaly();
+                return;
+            }
+            for (const symbol of delta.addedSymbolList) {
+                try {
+                    const outcome = await this.ensureSymbolLoaded(symbol);
+                    if (outcome === 'loaded') {
+                        this.emit('symbolAdded', symbol);
+                    }
+                }
+                catch (error) {
+                    // symbolLoadFailed was already emitted inside ensureSymbolLoaded (feeds the digest); the
+                    // next hourly sync retries the listing, and one bad listing must not kill the whole sync.
+                    logger.warn({ symbol, error }, `[MarketData] ${symbol} new listing failed to load — will retry on the next sync [${this.interval}]`);
+                }
+            }
+            const removalDecision = evaluateSymbolRemovalList({
+                removedSymbolList: delta.removedSymbolList,
+                loadedSymbolCount,
+                pendingRemovalSet: this.pendingRemovalSet,
+            });
+            this.pendingRemovalSet = removalDecision.nextPendingRemovalSet;
+            for (const symbol of removalDecision.approvedRemovalList) {
+                this.emit('symbolRemoved', symbol);
+                this.releaseSymbol(symbol);
+            }
+            if (removalDecision.deferredRemovalList.length > 0) {
+                logger.error({ deferredCount: removalDecision.deferredRemovalList.length, loadedSymbolCount }, `[MarketData] Symbol sync anomaly — exchange list dropped ${removalDecision.deferredRemovalList.length}/${loadedSymbolCount} symbols; removals deferred until the next sync confirms [${this.interval}]`);
+                if (!this.isSymbolSyncAnomalyActive) {
+                    this.isSymbolSyncAnomalyActive = true;
+                    this.emit('symbolSyncAnomaly', removalDecision.deferredRemovalList.length, loadedSymbolCount);
+                }
+            }
+            else {
+                this.resolveSymbolSyncAnomaly();
+            }
+            logger.info({ addedCount: delta.addedSymbolList.length, removedCount: removalDecision.approvedRemovalList.length, deferredCount: removalDecision.deferredRemovalList.length }, `[MarketData] Symbol list synced — +${delta.addedSymbolList.length} / -${removalDecision.approvedRemovalList.length} (deferred ${removalDecision.deferredRemovalList.length}) [${this.interval}]`);
+        }
+        catch (error) {
+            logger.error({ error }, `[MarketData] syncAllSymbols failed [${this.interval}]`);
+        }
+    }
+    resolveSymbolSyncAnomaly() {
+        if (this.isSymbolSyncAnomalyActive) {
+            this.isSymbolSyncAnomalyActive = false;
+            logger.info({}, `[MarketData] Symbol sync anomaly cleared [${this.interval}]`);
+        }
+    }
+    async shutdown() {
+        this.emit('sourceShutdown');
+        this.isShutDown = true;
+        const exchangeClient = this.exchangeConnector.futures;
+        // Snapshot the footprint before the cleanup so the teardown log reports what was actually freed.
+        const releasedSymbolCount = this.klineListBySymbol.size;
+        const releasedKlineCount = this.getKlineCount();
+        if (this.stalenessSchedulerHandle !== null) {
+            this.stalenessSchedulerHandle.stop();
+            this.stalenessSchedulerHandle = null;
+        }
+        if (this.silenceSchedulerHandle !== null) {
+            this.silenceSchedulerHandle.stop();
+            this.silenceSchedulerHandle = null;
+        }
+        if (this.volumeSchedulerHandle !== null) {
+            this.volumeSchedulerHandle.stop();
+            this.volumeSchedulerHandle = null;
+        }
+        for (const subscription of this.subscriptionBySymbol.values()) {
+            try {
+                exchangeClient.unsubscribeKlines(subscription);
+            }
+            catch (error) {
+                logger.warn({ symbol: subscription.symbol, error }, `[MarketData] ${subscription.symbol} shutdown — unsubscribeKlines failed (continuing cleanup) [${this.interval}]`);
+            }
+        }
+        // Free every per-symbol buffer explicitly instead of trusting the whole instance to be
+        // garbage-collected: a backfill or gap-repair task still queued in the shared pacer keeps this
+        // source reachable through its closure, so without these clears the kline history (the heavy
+        // part — up to KLINE_BUFFER_SIZE candles per symbol) stays resident until that task drains.
+        this.subscriptionBySymbol.clear();
+        this.handlerBySymbol.clear();
+        this.klineListBySymbol.clear();
+        this.maValuesBySymbol.clear();
+        this.currentKlineBySymbol.clear();
+        this.lastEmittedUpdateBySymbol.clear();
+        this.consecutiveStaleScanCountBySymbol.clear();
+        this.persistentStaleEmittedSet.clear();
+        this.skippedOlderKlineCountBySymbol.clear();
+        this.lastEmittedVolumeBySymbol.clear();
+        this.lastGapRepairAtMsBySymbol.clear();
+        this.gapRepairInFlightSet.clear();
+        this.gapRepairPendingSymbolList.length = 0;
+        this.gapRepairFetchCountBySymbol.clear();
+        this.backfillConvergedSet.clear();
+        this.pendingBackfillConvergeSet.clear();
+        this.convergedReprobeCountBySymbol.clear();
+        this.acceptedHistoryStartMsBySymbol.clear();
+        this.pendingRemovalSet = new Set();
+        // Drop the forwarding listeners the server attached (emit('sourceShutdown') above already ran
+        // synchronously) so nothing external pins this dead source in memory.
+        this.removeAllListeners();
+        logger.info({ releasedSymbolCount, releasedKlineCount }, `[MarketData] Interval torn down — released ${releasedSymbolCount} symbols, ${releasedKlineCount} klines [${this.interval}]`);
+    }
+    async fetchKlinesWithTimeout(fetchPromise, timeoutMs, symbol) {
+        return withTimeout(fetchPromise, timeoutMs, `fetchKlines timeout after ${timeoutMs}ms for symbol ${symbol} [${this.interval}]`);
+    }
+    async loadKlines(symbolList) {
+        const exchangeClient = this.exchangeConnector.futures;
+        let loadedCount = 0;
+        const fetchResultList = await Promise.all(symbolList.map(async (symbol) => {
+            try {
+                // The shut-down check runs INSIDE the queue task: entries already queued behind the
+                // process-wide pacer must not fire their REST request after teardown.
+                const rawKlineList = await this.backfillQueue.execute(() => (this.isShutDown ? Promise.resolve([]) : this.fetchKlinesWithTimeout(exchangeClient.fetchKlines(symbol, this.interval, { limit: KLINE_BUFFER_SIZE }), LOAD_KLINES_TIMEOUT_MS, symbol)), `fetchKlines ${symbol} [${this.interval}]`);
+                const klineList = rawKlineList.slice(-KLINE_BUFFER_SIZE);
+                return { symbol, klineList };
+            }
+            catch (error) {
+                logger.warn({ symbol, error }, `[MarketData] ${symbol} Failed to load klines, skipping [${this.interval}]`);
+                return { symbol, klineList: [] };
+            }
+            finally {
+                loadedCount++;
+                if (loadedCount % KLINE_LOAD_PROGRESS_LOG_EVERY === 0 || loadedCount === symbolList.length) {
+                    logger.info({ loaded: loadedCount, total: symbolList.length }, `[MarketData] Kline loading progress ${loadedCount}/${symbolList.length} [${this.interval}]`);
+                }
+            }
+        }));
+        if (this.isShutDown) {
+            return;
+        }
+        for (const { symbol, klineList } of fetchResultList) {
+            if (klineList.length === 0) {
+                continue;
+            }
+            // A symbol with a live handler already went live via the on-demand path while this bulk load
+            // was fetching — its buffer is being fed by the stream and must not be rolled back to this
+            // (older) REST copy. Handler presence is the discriminator on purpose: a stale buffer left by
+            // a previously FAILED bulk attempt has NO handler and must be overwritten.
+            if (this.handlerBySymbol.has(symbol)) {
+                continue;
+            }
+            markBackfilledHistoryClosed(klineList);
+            this.klineListBySymbol.set(symbol, klineList);
+            const lastKline = klineList[klineList.length - 1];
+            if (lastKline.isClosed !== true) {
+                this.currentKlineBySymbol.set(symbol, lastKline);
+            }
+            this.recalculateAndStoreMa(symbol, klineList);
+        }
+    }
+    subscribeToKlines(symbolList) {
+        if (this.isShutDown) {
+            return;
+        }
+        const exchangeClient = this.exchangeConnector.futures;
+        for (const symbol of symbolList) {
+            if (!this.klineListBySymbol.has(symbol)) {
+                continue;
+            }
+            if (this.handlerBySymbol.has(symbol)) {
+                continue;
+            }
+            const handler = (_symbol, kline) => {
+                this.handleKline(symbol, kline);
+            };
+            this.handlerBySymbol.set(symbol, handler);
+            const subscription = { symbol, interval: this.interval, handler };
+            this.subscriptionBySymbol.set(symbol, subscription);
+            exchangeClient.subscribeKlines(subscription);
+            if (this.lastInboundAtMs === 0) {
+                this.lastInboundAtMs = Date.now();
+            }
+        }
+    }
+    handleKline(symbol, kline) {
+        if (this.isShutDown) {
+            return;
+        }
+        this.recordInboundMessage();
+        try {
+            this.handleKlineUnsafe(symbol, kline);
+        }
+        catch (error) {
+            logger.error({ error, symbol, kline }, `[MarketData] ${symbol} handleKline threw unexpected error — swallowing to keep SDK callback loop alive [${this.interval}]`);
+        }
+    }
+    recordInboundMessage() {
+        const nowMs = Date.now();
+        if (this.isStreamSilent) {
+            const silenceMs = this.lastInboundAtMs > 0 ? nowMs - this.lastInboundAtMs : 0;
+            this.isStreamSilent = false;
+            logger.info({ silenceMs }, `[MarketData] Stream resumed after ${Math.round(silenceMs / 1000)}s of silence [${this.interval}]`);
+            this.emit('streamResumed', silenceMs);
+        }
+        this.lastInboundAtMs = nowMs;
+    }
+    handleKlineUnsafe(symbol, kline) {
+        const klineList = this.klineListBySymbol.get(symbol);
+        if (klineList === undefined || klineList.length === 0) {
+            return;
+        }
+        const lastKline = klineList[klineList.length - 1];
+        const isOlder = kline.openTimestamp < lastKline.openTimestamp;
+        if (isOlder) {
+            const previousCount = this.skippedOlderKlineCountBySymbol.get(symbol) ?? 0;
+            this.skippedOlderKlineCountBySymbol.set(symbol, previousCount + 1);
+            return;
+        }
+        if (this.consecutiveStaleScanCountBySymbol.has(symbol) && this.isKlineFresh(kline)) {
+            this.consecutiveStaleScanCountBySymbol.delete(symbol);
+            if (this.persistentStaleEmittedSet.delete(symbol)) {
+                this.emit('persistentStaleRecovered', symbol);
+            }
+        }
+        const isNewCandle = kline.openTimestamp > lastKline.openTimestamp;
+        const intervalMs = resolveIntervalMs(this.interval);
+        const missedCandleCount = isNewCandle ? Math.floor((kline.openTimestamp - lastKline.openTimestamp) / intervalMs) - 1 : 0;
+        let repairFetchCount = 0;
+        if (isNewCandle && lastKline.isClosed !== true) {
+            lastKline.isClosed = true;
+            // Sealed locally = the exchange's closing frame was lost; the sealed values are the last seen,
+            // not the true close — schedule a REST repair to correct them.
+            this.locallyClosedCandleCount += 1;
+            repairFetchCount = GAP_REPAIR_BASE_FETCH_COUNT;
+            const maValues = this.recalculateAndStoreMa(symbol, klineList);
+            this.emitGuarded('klineClosed', symbol, lastKline, maValues);
+        }
+        if (missedCandleCount > 0) {
+            repairFetchCount = Math.max(repairFetchCount, missedCandleCount + GAP_REPAIR_BASE_FETCH_COUNT);
+        }
+        if (repairFetchCount > 0) {
+            this.scheduleGapRepair(symbol, repairFetchCount);
+        }
+        if (kline.isClosed === true) {
+            if (isNewCandle) {
+                klineList.push(kline);
+                if (klineList.length > KLINE_BUFFER_SIZE) {
+                    klineList.shift();
+                }
+            }
+            else {
+                klineList[klineList.length - 1] = kline;
+            }
+            this.currentKlineBySymbol.delete(symbol);
+            this.lastEmittedUpdateBySymbol.delete(symbol);
+            const maValues = this.recalculateAndStoreMa(symbol, klineList);
+            this.emitGuarded('klineClosed', symbol, kline, maValues);
+            return;
+        }
+        if (isNewCandle) {
+            klineList.push(kline);
+            if (klineList.length > KLINE_BUFFER_SIZE) {
+                klineList.shift();
+            }
+        }
+        else {
+            klineList[klineList.length - 1] = kline;
+        }
+        this.currentKlineBySymbol.set(symbol, kline);
+        const nowMs = Date.now();
+        const lastRecompute = this.lastEmittedUpdateBySymbol.get(symbol);
+        const isMaRecomputeThrottled = lastRecompute !== undefined
+            && lastRecompute.openTimestamp === kline.openTimestamp
+            && nowMs - lastRecompute.emittedAtMs < KLINE_UPDATE_THROTTLE_MS;
+        let maValues;
+        if (isMaRecomputeThrottled) {
+            maValues = this.maValuesBySymbol.get(symbol) ?? ZERO_MA;
+            this.throttledMaRecomputeCount += 1;
+        }
+        else {
+            maValues = this.recalculateAndStoreMa(symbol, klineList);
+            this.lastEmittedUpdateBySymbol.set(symbol, { openTimestamp: kline.openTimestamp, emittedAtMs: nowMs });
+        }
+        this.emitGuarded('klineUpdated', symbol, kline, maValues);
+        this.emitTickGuarded(symbol, kline);
+    }
+    scheduleGapRepair(symbol, fetchCount) {
+        if (this.isShutDown) {
+            return;
+        }
+        const previousFetchCount = this.gapRepairFetchCountBySymbol.get(symbol) ?? 0;
+        this.gapRepairFetchCountBySymbol.set(symbol, Math.min(Math.max(fetchCount, previousFetchCount), KLINE_BUFFER_SIZE));
+        if (this.gapRepairInFlightSet.has(symbol) || this.gapRepairPendingSymbolList.includes(symbol)) {
+            return;
+        }
+        const lastRepairAtMs = this.lastGapRepairAtMsBySymbol.get(symbol);
+        if (lastRepairAtMs !== undefined && Date.now() - lastRepairAtMs < GAP_REPAIR_COOLDOWN_MS) {
+            return;
+        }
+        this.gapRepairPendingSymbolList.push(symbol);
+        this.drainGapRepairQueue();
+    }
+    drainGapRepairQueue() {
+        while (!this.isShutDown && this.gapRepairInFlightSet.size < MAX_CONCURRENT_GAP_REPAIRS && this.gapRepairPendingSymbolList.length > 0) {
+            const symbol = this.gapRepairPendingSymbolList.shift();
+            this.gapRepairInFlightSet.add(symbol);
+            void this.runGapRepair(symbol).finally(() => {
+                this.gapRepairInFlightSet.delete(symbol);
+                this.drainGapRepairQueue();
+            });
+        }
+    }
+    async runGapRepair(symbol) {
+        // Released/delisted while waiting in the queue — no buffer to repair, no REST slot to burn.
+        if (!this.klineListBySymbol.has(symbol)) {
+            this.gapRepairFetchCountBySymbol.delete(symbol);
+            return;
+        }
+        const fetchCount = this.gapRepairFetchCountBySymbol.get(symbol) ?? GAP_REPAIR_BASE_FETCH_COUNT;
+        this.gapRepairFetchCountBySymbol.delete(symbol);
+        this.lastGapRepairAtMsBySymbol.set(symbol, Date.now());
+        const exchangeClient = this.exchangeConnector.futures;
+        try {
+            const rawKlineList = await this.backfillQueue.execute(() => (this.isShutDown ? Promise.resolve([]) : this.fetchKlinesWithTimeout(exchangeClient.fetchKlines(symbol, this.interval, { limit: fetchCount }), LOAD_KLINES_TIMEOUT_MS, symbol)), `gapRepair ${symbol} [${this.interval}]`);
+            if (this.isShutDown) {
+                return;
+            }
+            const bufferKlineList = this.klineListBySymbol.get(symbol);
+            // Released or delisted while the repair was in flight — do not resurrect the buffer.
+            if (bufferKlineList === undefined) {
+                return;
+            }
+            if (rawKlineList.length === 0) {
+                logger.warn({ symbol, fetchCount }, `[MarketData] ${symbol} gap repair got an empty history — the hole stays until the next detection [${this.interval}]`);
+                this.emit('symbolLoadFailed', symbol);
+                return;
+            }
+            const fetchedKlineList = rawKlineList.slice(-KLINE_BUFFER_SIZE);
+            markBackfilledHistoryClosed(fetchedKlineList);
+            const formingOpenTimestamp = this.currentKlineBySymbol.get(symbol)?.openTimestamp ?? null;
+            const mergeResult = mergeRepairedKlines({ bufferKlineList, fetchedKlineList, formingOpenTimestamp, maxBufferSize: KLINE_BUFFER_SIZE });
+            if (mergeResult.changedCount === 0) {
+                this.handleRepairConverged(symbol, bufferKlineList, fetchCount);
+                return;
+            }
+            // Data arrived — any pending convergence conclusion is stale. Dropping the converged flag
+            // resumes the scan's full backfills; "recovered" fires only when the history actually caught
+            // up (a partial merge must not read as a recovery in the operator digest).
+            this.pendingBackfillConvergeSet.delete(symbol);
+            this.convergedReprobeCountBySymbol.delete(symbol);
+            const wasConverged = this.backfillConvergedSet.delete(symbol);
+            this.klineListBySymbol.set(symbol, mergeResult.mergedKlineList);
+            this.recalculateAndStoreMa(symbol, mergeResult.mergedKlineList);
+            logger.info({ symbol, changedCount: mergeResult.changedCount, fetchCount }, `[MarketData] ${symbol} gap repair merged ${mergeResult.changedCount} candle(s) — reseeding clients [${this.interval}]`);
+            this.emit('symbolReseeded', symbol);
+            if (wasConverged && !this.isSymbolUndergrown(symbol, mergeResult.mergedKlineList)) {
+                this.emit('symbolBackfillRecovered', symbol);
+            }
+        }
+        catch (error) {
+            logger.error({ symbol, error }, `[MarketData] ${symbol} gap repair failed — the hole stays until the next detection [${this.interval}]`);
+            this.emit('symbolLoadFailed', symbol);
+        }
+    }
+    recalculateAndStoreMa(symbol, klineList) {
+        const maValues = calculateAllMaValues(klineList);
+        this.maValuesBySymbol.set(symbol, maValues);
+        return maValues;
+    }
+    isKlineFresh(kline) {
+        const intervalMs = resolveIntervalMs(this.interval);
+        const klineEndMs = kline.openTimestamp + intervalMs;
+        const klineAgeMs = Date.now() - klineEndMs;
+        const thresholdMs = STALENESS_THRESHOLD_MULTIPLIER * intervalMs;
+        return klineAgeMs <= thresholdMs;
+    }
+    emitTickGuarded(symbol, kline) {
+        if (!this.isKlineFresh(kline)) {
+            return;
+        }
+        this.emit('klineUpdatedTick', symbol, kline);
+    }
+    emitGuarded(eventName, symbol, kline, maValues) {
+        if (!this.isKlineFresh(kline)) {
+            this.skippedStaleEmitCount += 1;
+            return;
+        }
+        this.emit(eventName, symbol, kline, maValues);
+    }
+    startStalenessWatchdog() {
+        this.stalenessSchedulerHandle = startIntervalScheduler({
+            tickHandler: () => this.stalenessScan(),
+            intervalMs: STALENESS_CHECK_INTERVAL_MS,
+            contextLabel: `[MarketData] Staleness scan failed [${this.interval}]`,
+            heartbeatEveryNTicks: STALENESS_HEARTBEAT_EVERY_N_TICKS,
+            heartbeatHandler: (tickCount) => {
+                const symbolCount = this.klineListBySymbol.size;
+                const persistentStaleCount = this.consecutiveStaleScanCountBySymbol.size;
+                const throttledMaRecomputeCount = this.throttledMaRecomputeCount;
+                this.throttledMaRecomputeCount = 0;
+                const skippedStaleEmitCount = this.skippedStaleEmitCount;
+                this.skippedStaleEmitCount = 0;
+                const locallyClosedCandleCount = this.locallyClosedCandleCount;
+                this.locallyClosedCandleCount = 0;
+                logger.info({ tickCount, symbolCount, persistentStaleCount, throttledMaRecomputeCount, skippedStaleEmitCount, locallyClosedCandleCount }, `[MarketData] Staleness watchdog alive — tick #${tickCount}, ${symbolCount} symbols monitored, ${persistentStaleCount} persistent stale, ${throttledMaRecomputeCount} MA recomputes throttled, ${skippedStaleEmitCount} stale emits skipped, ${locallyClosedCandleCount} candles sealed locally in last period [${this.interval}]`);
+                this.flushSkippedOlderKlineCounters();
+            },
+        });
+        logger.info({ intervalMs: STALENESS_CHECK_INTERVAL_MS }, `[MarketData] Staleness watchdog started (check every ${STALENESS_CHECK_INTERVAL_MS / 1000}s) [${this.interval}]`);
+    }
+    startSilenceWatchdog() {
+        this.silenceSchedulerHandle = startIntervalScheduler({
+            tickHandler: () => this.silenceScan(),
+            intervalMs: SILENCE_CHECK_INTERVAL_MS,
+            contextLabel: `[MarketData] Silence scan failed [${this.interval}]`,
+        });
+        logger.info({ intervalMs: SILENCE_CHECK_INTERVAL_MS, thresholdMs: SILENCE_THRESHOLD_MS }, `[MarketData] Silence watchdog started (check every ${SILENCE_CHECK_INTERVAL_MS / 1000}s, threshold ${SILENCE_THRESHOLD_MS / 1000}s) [${this.interval}]`);
+    }
+    silenceScan() {
+        if (this.subscriptionBySymbol.size === 0 || this.lastInboundAtMs === 0) {
+            return;
+        }
+        const silenceMs = Date.now() - this.lastInboundAtMs;
+        if (silenceMs <= SILENCE_THRESHOLD_MS || this.isStreamSilent) {
+            return;
+        }
+        this.isStreamSilent = true;
+        logger.warn({ silenceMs, thresholdMs: SILENCE_THRESHOLD_MS, subscriptionCount: this.subscriptionBySymbol.size }, `[MarketData] Stream SILENT — no inbound message for ${Math.round(silenceMs / 1000)}s across ${this.subscriptionBySymbol.size} subscriptions [${this.interval}]`);
+        this.emit('streamSilent', silenceMs);
+    }
+    startVolumeRefreshScheduler() {
+        this.volumeSchedulerHandle = startIntervalScheduler({
+            tickHandler: () => this.refreshVolumes(),
+            intervalMs: VOLUME_REFRESH_INTERVAL_MS,
+            contextLabel: `[MarketData] Volume refresh failed [${this.interval}]`,
+        });
+    }
+    refreshVolumes() {
+        for (const symbol of this.klineListBySymbol.keys()) {
+            const volume24hUsdt = this.getVolume24h(symbol);
+            if (!Number.isFinite(volume24hUsdt)) {
+                continue;
+            }
+            if (this.lastEmittedVolumeBySymbol.get(symbol) === volume24hUsdt) {
+                continue;
+            }
+            this.lastEmittedVolumeBySymbol.set(symbol, volume24hUsdt);
+            this.emit('volume24h', symbol, volume24hUsdt);
+        }
+    }
+    stalenessScan() {
+        const intervalMs = resolveIntervalMs(this.interval);
+        const thresholdMs = STALENESS_THRESHOLD_MULTIPLIER * intervalMs;
+        const nowMs = Date.now();
+        let staleCount = 0;
+        for (const [symbol, klineList] of this.klineListBySymbol) {
+            if (klineList.length === 0) {
+                continue;
+            }
+            const lastKline = klineList[klineList.length - 1];
+            const referenceTimestamp = lastKline.closeTimestamp > 0 ? lastKline.closeTimestamp : lastKline.openTimestamp + intervalMs;
+            const ageMs = nowMs - referenceTimestamp;
+            if (ageMs <= thresholdMs) {
+                continue;
+            }
+            staleCount += 1;
+            const previousCount = this.consecutiveStaleScanCountBySymbol.get(symbol) ?? 0;
+            const nextCount = previousCount + 1;
+            this.consecutiveStaleScanCountBySymbol.set(symbol, nextCount);
+            if (nextCount === PERSISTENT_STALE_THRESHOLD_TICK_COUNT) {
+                logger.warn({ symbol, count: nextCount }, `[MarketData] ${symbol} Persistent stale threshold reached (${nextCount} consecutive stale ticks) [${this.interval}]`);
+                this.persistentStaleEmittedSet.add(symbol);
+                this.emit('persistentStaleSymbol', symbol);
+            }
+        }
+        if (staleCount > 0) {
+            logger.warn({ staleCount, totalSymbols: this.klineListBySymbol.size }, `[MarketData] Staleness scan found ${staleCount} stale symbol(s) out of ${this.klineListBySymbol.size} [${this.interval}]`);
+        }
+        this.evaluateMassStale(staleCount);
+        this.scanUndergrownSymbols();
+    }
+    // A symbol whose buffer is far below the history its listing time implies (a truncated load that
+    // would otherwise stay broken until a full restart — `computeSymbolListDelta` never re-adds an
+    // already-loaded symbol) is re-backfilled through the shared gap-repair queue. Converged symbols
+    // are left alone until their buffer changes on its own (live stream), which clears the flag.
+    scanUndergrownSymbols() {
+        for (const [symbol, klineList] of this.klineListBySymbol) {
+            const expectedCount = this.computeExpectedKlineCount(symbol);
+            // Unknown history anchor (the symbol momentarily absent from the trade-symbol cache after a
+            // flaky exchange list read): leave every state untouched — "unknown" must never read as
+            // "healthy" (a false recovery) nor as "broken" (a false backfill).
+            if (expectedCount === null) {
+                continue;
+            }
+            const isUndergrown = klineList.length + UNDERGROWN_TOLERANCE < expectedCount;
+            if (this.backfillConvergedSet.has(symbol)) {
+                if (!isUndergrown) {
+                    this.backfillConvergedSet.delete(symbol);
+                    this.convergedReprobeCountBySymbol.delete(symbol);
+                    this.emit('symbolBackfillRecovered', symbol);
+                    continue;
+                }
+                const lastRepairAtMs = this.lastGapRepairAtMsBySymbol.get(symbol) ?? 0;
+                if (Date.now() - lastRepairAtMs >= CONVERGED_REPROBE_INTERVAL_MS) {
+                    this.scheduleGapRepair(symbol, KLINE_BUFFER_SIZE);
+                }
+                continue;
+            }
+            if (isUndergrown) {
+                this.scheduleGapRepair(symbol, KLINE_BUFFER_SIZE);
+            }
+            else {
+                // Live growth caught the buffer up — a stale pending vote must not combine with a much
+                // later convergence into a premature latch.
+                this.pendingBackfillConvergeSet.delete(symbol);
+            }
+        }
+    }
+    // Expected candle count from the symbol's history anchor, capped at the buffer size. The anchor
+    // is the listing time, overridden by an exchange-confirmed (accepted) history start when the
+    // symbol's short history was repeatedly reconfirmed. Returns null when neither is known (never
+    // seen in production for Bybit/Binance, which always populate the listing time) — an unknown
+    // expectation must not flag a symbol, so the scan skips it.
+    computeExpectedKlineCount(symbol) {
+        const tradeSymbolBySymbol = this.exchangeConnector.futures.tradeSymbols;
+        const launchTimestamp = tradeSymbolBySymbol?.get(symbol)?.launchTimestamp;
+        const isLaunchKnown = launchTimestamp !== undefined && Number.isFinite(launchTimestamp) && launchTimestamp > 0;
+        const acceptedStartMs = this.acceptedHistoryStartMsBySymbol.get(symbol);
+        let anchorMs = isLaunchKnown ? launchTimestamp : undefined;
+        if (acceptedStartMs !== undefined && (anchorMs === undefined || acceptedStartMs > anchorMs)) {
+            anchorMs = acceptedStartMs;
+        }
+        if (anchorMs === undefined) {
+            return null;
+        }
+        const elapsedMs = Date.now() - anchorMs;
+        if (elapsedMs <= 0) {
+            return 0;
+        }
+        return Math.min(KLINE_BUFFER_SIZE, Math.floor(elapsedMs / resolveIntervalMs(this.interval)));
+    }
+    isSymbolUndergrown(symbol, klineList) {
+        const expectedCount = this.computeExpectedKlineCount(symbol);
+        if (expectedCount === null) {
+            return false;
+        }
+        return klineList.length + UNDERGROWN_TOLERANCE < expectedCount;
+    }
+    // A repair fetched fresh data yet merged nothing. Only a FULL-window request may argue the
+    // exchange has nothing more (a 2-candle seal/hole repair returning known candles proves nothing
+    // about the missing depth), and even a full window must converge twice in a row before the latch.
+    handleRepairConverged(symbol, bufferKlineList, fetchCount) {
+        if (fetchCount < KLINE_BUFFER_SIZE) {
+            return;
+        }
+        if (!this.isSymbolUndergrown(symbol, bufferKlineList)) {
+            this.pendingBackfillConvergeSet.delete(symbol);
+            return;
+        }
+        if (this.backfillConvergedSet.has(symbol)) {
+            this.recordConvergedReprobe(symbol, bufferKlineList);
+            return;
+        }
+        if (!this.pendingBackfillConvergeSet.has(symbol)) {
+            this.pendingBackfillConvergeSet.add(symbol);
+            return;
+        }
+        this.pendingBackfillConvergeSet.delete(symbol);
+        this.backfillConvergedSet.add(symbol);
+        logger.warn({ symbol, bufferSize: bufferKlineList.length }, `[MarketData] ${symbol} backfill converged below its expected history twice in a row — the exchange serves no more candles [${this.interval}]`);
+        this.emit('symbolBackfillStuck', symbol);
+    }
+    // An hourly re-probe of a latched symbol reconfirmed the convergence. After enough consecutive
+    // reconfirmations the short history is accepted as the exchange's truth: the expectation is
+    // re-anchored at the symbol's own first candle and the symbol leaves the digest.
+    recordConvergedReprobe(symbol, bufferKlineList) {
+        const reprobeCount = (this.convergedReprobeCountBySymbol.get(symbol) ?? 0) + 1;
+        if (reprobeCount < CONVERGED_ACCEPT_REPROBE_COUNT) {
+            this.convergedReprobeCountBySymbol.set(symbol, reprobeCount);
+            return;
+        }
+        const historyStartMs = bufferKlineList[0].openTimestamp;
+        this.acceptedHistoryStartMsBySymbol.set(symbol, historyStartMs);
+        this.backfillConvergedSet.delete(symbol);
+        this.convergedReprobeCountBySymbol.delete(symbol);
+        logger.info({ symbol, historyStartMs, bufferSize: bufferKlineList.length }, `[MarketData] ${symbol} short history accepted as the exchange's truth after ${CONVERGED_ACCEPT_REPROBE_COUNT} reconfirming re-probes — history starts at ${new Date(historyStartMs).toISOString()} [${this.interval}]`);
+        this.emit('symbolBackfillRecovered', symbol);
+    }
+    evaluateMassStale(staleCount) {
+        const symbolCount = this.klineListBySymbol.size;
+        const isMassStaleNow = crossesMassStaleThreshold({ staleCount, symbolCount, ratioThreshold: MASS_STALE_RATIO_THRESHOLD, minSymbols: MASS_STALE_MIN_SYMBOLS });
+        if (isMassStaleNow && !this.isMassStale) {
+            this.isMassStale = true;
+            logger.warn({ staleCount, symbolCount }, `[MarketData] MASS STALE — ${staleCount}/${symbolCount} symbols stale, escalating as a whole-source degradation [${this.interval}]`);
+            this.emit('sourceMassStale', staleCount, symbolCount);
+            return;
+        }
+        if (!isMassStaleNow && this.isMassStale) {
+            this.isMassStale = false;
+            logger.info({ staleCount, symbolCount }, `[MarketData] Mass stale recovered — ${staleCount}/${symbolCount} symbols stale [${this.interval}]`);
+            this.emit('sourceMassStaleRecovered', staleCount, symbolCount);
+        }
+    }
+    flushSkippedOlderKlineCounters() {
+        if (this.skippedOlderKlineCountBySymbol.size === 0) {
+            return;
+        }
+        const countBySymbol = {};
+        let totalCount = 0;
+        for (const [symbol, count] of this.skippedOlderKlineCountBySymbol) {
+            countBySymbol[symbol] = count;
+            totalCount += count;
+        }
+        const symbolCount = this.skippedOlderKlineCountBySymbol.size;
+        logger.info({ countBySymbol, totalCount, symbolCount }, `[MarketData] Skipped replayed older klines since last heartbeat: ${totalCount} total across ${symbolCount} symbol(s) [${this.interval}]`);
+        this.skippedOlderKlineCountBySymbol.clear();
+    }
+}
+export { MarketDataManager };
+//# sourceMappingURL=marketDataManager.js.map