@vkontakte/calls-sdk 2.8.13-dev.89692622.0 → 2.8.13-dev.8d49bb21.0

package/classes/AudioOutput.d.ts

@@ -15,6 +15,7 @@ export default class AudioOutput {
     private readonly _features;
     private readonly _statFirstMediaReceived;
     private readonly _logger;
+    private _autoplayRecoveryController;
     constructor(statFirstMediaReceived: StatFirstMediaReceived, allowMultipleTracks?: boolean, debug?: DebugLogger, logger?: StatEventCollector | null);
     add(participantId: ParticipantId, track: MediaStreamTrack): void;
     remove(participantId: ParticipantId, track: MediaStreamTrack): void;
@@ -26,6 +27,7 @@ export default class AudioOutput {
     protected _getTracks(): MediaStreamTrack[];
     protected _initAudioElement(): void;
     protected _stopAudioElement(): void;
+    private _stopAutoplayRecovery;
     private _createAudioElement;
     private _prepareAudioElement;
     private _addTrackToAudioElement;

package/classes/CallRegistry.d.ts

@@ -6,18 +6,31 @@ export interface HoldableConversation extends Conversation {
 }
 export declare class CallRegistry {
     private _conversations;
-    private _reserved;
+    private _pending;
+    private _initialIds;
+    private _hangups;
     private _activeId;
+    private _selected;
     private _mutex;
     private _pendingRemovals;
-    reserve(id: string): void;
+    addPending(conversation: HoldableConversation): void;
+    selectPending(conversation: HoldableConversation): HoldableConversation | null;
+    isSelected(conversation: HoldableConversation): boolean;
+    releaseSelection(conversation: HoldableConversation, previous?: HoldableConversation | null): void;
+    selectIfNone(conversation: HoldableConversation): void;
     add(conversation: HoldableConversation): void;
-    remove(id: string | null): void;
+    remove(conversation: HoldableConversation): void;
     get(id: string): HoldableConversation | undefined;
+    getPending(id?: string): HoldableConversation | null;
+    isPending(conversation: HoldableConversation): boolean;
+    getLocal(id?: string): HoldableConversation | null;
+    trackHangup(conversation: HoldableConversation, promise: Promise<void>): void;
+    getHangup(id?: string): Promise<void> | undefined;
+    removeHangup(promise: Promise<void>): void;
     getActive(): HoldableConversation | null;
     getFirst(): HoldableConversation | null;
     getActiveId(): string | null;
-    has(id: string): boolean;
+    has(id: string, except?: HoldableConversation): boolean;
     getAll(): HoldableConversation[];
     get callsLength(): number;
     setActive(id: string): Promise<void>;

package/classes/MediaSource.d.ts

@@ -1,5 +1,6 @@
 import type { IEffect } from '@vkontakte/calls-video-effects';
 import EventEmitter from '../classes/EventEmitter';
+import ActiveFeature from '../enums/ActiveFeature';
 import MediaOption from '../enums/MediaOption';
 import { type DebugLogger } from '../static/Debug';
 import MediaSettings, { IVideoDimentions } from '../types/MediaSettings';
@@ -38,6 +39,8 @@ export declare class MediaSource extends EventEmitter {
     private _screenTrack;
     private _audioShareTrack;
     private _screenShareTrack;
+    private _screenCaptureRequest;
+    private _destroyed;
     /** Трек для отправки в медиа-канал. Может отличаться при скриншаринге в дата-канал */
     private _sendVideoTrack;
     /** Трек с камеры. В стриме будет другой трек при включенных видео эффектах */
@@ -77,6 +80,8 @@ export declare class MediaSource extends EventEmitter {
      */
     getMediaSettings(): MediaSettings;
     get mediaSettings(): MediaSettings;
+    /** Что сейчас включено у пользователя — для метрики active_features */
+    get activeFeatures(): ActiveFeature[];
     changeDevice(kind: MediaDeviceKind): Promise<void>;
     /**
      * Установка кастомного стрима для видео, например внешний шаринг экрана
@@ -125,6 +130,11 @@ export declare class MediaSource extends EventEmitter {
     updateNoiseSuppression(): Promise<void>;
     videoEffect(effect: IEffect | null): Promise<void>;
     audioEffect(audioEffectParams: AudioEffectParams | null): Promise<void>;
+    /**
+     * Копия микрофона всегда включена: clone() копирует enabled,
+     * а VAD выключает трек микрофона, пока человек молчит
+     */
+    private _cloneMicAudioTrack;
     getAudioShareTrack(): MediaStreamTrack | null;
     private handleVideoEffectsLowFps;
     private get _frameRate();

package/classes/StatsLogger.d.ts

@@ -2,7 +2,7 @@ import BaseApi from '../abstract/BaseApi';
 import BaseLogger from '../abstract/BaseLogger';
 import StatLog from '../enums/StatLog';
 import TransportTopology from '../enums/TransportTopology';
-type ClientStatsPayload = Record<string, string | number | boolean | undefined | null>;
+type ClientStatsPayload = Record<string, string | string[] | number | boolean | undefined | null>;
 export type LogClientStatsOptions = {
     immediately?: boolean;
     occurredAt?: number;

package/classes/conversation/Conversation.d.ts

@@ -15,7 +15,7 @@ import { IAsrStartParams, IAsrStopParams } from '../../types/Asr';
 import { AudienceModeHandsResponse } from '../../types/AudienceMode';
 import { ConversationData, ConversationOnJoinParams, ConversationOnStartParams } from '../../types/Conversation';
 import { ExternalId, ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk } from '../../types/ExternalId';
-import type { FastHangupHandler, HangupParams } from '../../types/FastHangup';
+import type { HangupParams } from '../../types/FastHangup';
 import MediaModifiers from '../../types/MediaModifiers';
 import MediaSettings, { IVideoDimentions } from '../../types/MediaSettings';
 import { IAddMovieParams, IUpdateMovieData } from '../../types/MovieShare';
@@ -35,6 +35,9 @@ export default class Conversation extends EventEmitter {
     private readonly _signalingActor;
     private readonly _displayLayoutRequester;
     private _mediaSource;
+    private _requestingLocalMedia;
+    private _requestedLocalAudio?;
+    private _requestedLocalVideo?;
     private _conversation;
     private _myLastRequestedLayouts;
     private _state;
@@ -56,16 +59,20 @@ export default class Conversation extends EventEmitter {
     private _isRealTimeAsrRequested;
     private _serverSettings;
     private _serverTimeOffset;
-    private _delayedHangup;
+    private _serverConversationId;
     private _onFastHangup?;
     private _hangupEmitted;
     private _hangupPromise;
+    private _hangupReason;
     private _abortController;
     private _registeredPeerReceived;
     private _calleeUnavailableTimer;
-    private _reservedId;
+    private _pendingId;
+    private _resolveSignalingInitialization;
+    private readonly _signalingInitialization;
     private readonly _onUnload;
     private readonly _onRestore;
+    private readonly _onVisibilityChange;
     private readonly _audioOutput;
     private readonly _stats;
     private _lastStalled;
@@ -80,7 +87,6 @@ export default class Conversation extends EventEmitter {
     private readonly _statFirstMediaReceived;
     constructor(api: BaseApi, externalLogger: BaseLogger | null);
     static current(): Conversation | null;
-    static hangupAfterInit(onFastHangup?: FastHangupHandler): void;
     static id(): string | null;
     get id(): string;
     get externalId(): ExternalParticipantId | undefined;
@@ -116,7 +122,8 @@ export default class Conversation extends EventEmitter {
     accept(mediaOptions: MediaOption[]): Promise<ConversationData>;
     decline(params?: HangupParams): Promise<void>;
     hangup(params?: HangupParams): Promise<void>;
-    addParticipant(participantIds: ExternalId[], params?: AddParticipantParams): Promise<void>;
+    private _waitForHangup;
+    addParticipant(participantIds: ExternalId[], params?: AddParticipantParams): Promise<ExternalParticipant[] | undefined>;
     addParticipantLegacy(participantIds: CompositeUserId[], params?: AddParticipantParams): Promise<void>;
     removeParticipant(participantId: CompositeUserId, ban?: boolean): Promise<void>;
     setVolume(volume: number): void;
@@ -124,11 +131,15 @@ export default class Conversation extends EventEmitter {
     private _openTransport;
     private _allocateParticipantTransport;
     private _closeParticipantTransport;
+    private _registerPending;
     private _cleanupRegistry;
+    private _applyInitialActiveSelection;
     private _emitHangupOnce;
     private _sendHangupApi;
     private _close;
     private _sendHangup;
+    private _throwIfClosed;
+    private _applyServerConversation;
     destroy(): void;
     private _destroy;
     private _getConversationParams;
@@ -152,12 +163,15 @@ export default class Conversation extends EventEmitter {
     private _cacheParticipantExternalIds;
     private _setConversation;
     private _updateConversation;
+    private _requestLocalMedia;
     private _createMediaSource;
     private _connectSignaling;
+    private _completeSignalingInitialization;
     private _processConnection;
     private _onConversationParticipantListChunk;
     private _createParticipantListChunk;
     private _participantListChunkToExternalChunk;
+    private _participantsToExternal;
     private _registerConnectionParticipants;
     private _registerParticipants;
     /** Установим состояние локальных мьютов */
@@ -452,6 +466,11 @@ export default class Conversation extends EventEmitter {
     private _onVideoSuspendSuggest;
     private _onParticipantHold;
     private _isMe;
+    /**
+     * Сколько человек сейчас в звонке. Считаем только принявших: приглашенные,
+     * у которых еще идет вызов, ресурсы не потребляют.
+     */
+    private _getParticipantsCount;
     private _getMuteStatesForRoomId;
     private _getMuteStatesForCurrentRoom;
     private _setMuteStatesForRoomId;
@@ -459,8 +478,6 @@ export default class Conversation extends EventEmitter {
     private _registerParticipant;
     private _getParticipant;
 }
-declare function _resetPendingInstance(): void;
-export { _resetPendingInstance };
 export declare class UpdateDisplayLayoutError extends Error {
     readonly participantErrors: {
         externalId: ExternalParticipantId;

package/classes/conversation/Conversation.testUtils.d.ts

@@ -37,6 +37,7 @@ declare function createParams(): {
     onSpeakerChanged: Mock<import("@vitest/spy").Procedure>;
     onAcceptedCall: Mock<import("@vitest/spy").Procedure>;
     onNonFatalError: Mock<import("@vitest/spy").Procedure>;
+    onSignalingConnected: Mock<import("@vitest/spy").Procedure>;
 };
 export type ConversationTestParams = ReturnType<typeof createParams>;
 export type ConversationTestTools = {

package/classes/stat/BatteryStats.d.ts

@@ -0,0 +1,25 @@
+import StatEventCollector from './StatEventCollector';
+export interface BatteryClock {
+    monotonicNow(): number;
+}
+/**
+ * Метрика battery_level_change: на каждое изменение уровня заряда отправляется
+ * само изменение в процентных пунктах и время, за которое оно произошло.
+ * Пока устройство на зарядке, замеры не ведутся: зарядка сбрасывает точку отсчёта,
+ * и первое изменение после неё только задаёт новую.
+ *
+ * Battery Status API есть только в Chromium, в Safari и Firefox его нет —
+ * там класс молча ничего не делает.
+ */
+export declare class BatteryStats {
+    private readonly _logger;
+    private readonly _clock;
+    private _battery;
+    private _previous;
+    private _destroyed;
+    constructor(logger: StatEventCollector, clock?: BatteryClock);
+    destroy(): void;
+    private _subscribe;
+    private _handleChargingChange;
+    private _handleLevelChange;
+}

package/classes/stat/CallLifecycleStats.d.ts

@@ -1,4 +1,5 @@
 import StatEventCollector from './StatEventCollector';
+import { CallStatTail } from './CallStatTail';
 export type CallLifecycleSource = 'outgoing' | 'incoming' | 'join' | 'anonym_join';
 export interface CallLifecycleInitializationParams {
     source: CallLifecycleSource;
@@ -11,6 +12,7 @@ export interface CallLifecycleClock {
 export declare class CallLifecycleStats {
     private readonly _logger;
     private readonly _clock;
+    private readonly _tail;
     private _conversationId;
     private _callStartLabel;
     private _lifecycleStartedAtMonotonic;
@@ -20,7 +22,7 @@ export declare class CallLifecycleStats {
     private _firstMediaSent;
     private _finished;
     private _destroyed;
-    constructor(logger: StatEventCollector, clock?: CallLifecycleClock);
+    constructor(logger: StatEventCollector, clock?: CallLifecycleClock, tail?: CallStatTail | null);
     get firstMediaSentReported(): boolean;
     get terminated(): boolean;
     markInitializationStarted({ source, conversationId }: CallLifecycleInitializationParams): void;
@@ -34,6 +36,7 @@ export declare class CallLifecycleStats {
     destroy(): void;
     private _canRecord;
     private _durationSince;
+    private _startTail;
     private _finish;
     private _ensureConversationId;
     private _record;

package/classes/stat/CallStatTail.d.ts

@@ -0,0 +1,65 @@
+import type StatEventCollector from './StatEventCollector';
+import type { ClientStatsPayload } from './StatEventCollector';
+export interface CallStatTailClock {
+    wallNow(): number;
+}
+/**
+ * Хвост звонка — заготовленный финиш на случай, если вкладка умрёт посреди
+ * звонка: call_finish с причиной terminated и итоги звонка. Лежит в отдельной
+ * таблице, не в очереди отправки, и раз в секунду перезаписывается. Время в
+ * нём — на шаг таймера позже текущего.
+ *
+ * Звонок закончился как обычно — хвост удаляется, а в очередь пишется
+ * настоящий финиш. Вкладку закрыли или убили — хвост остаётся, его перенесёт
+ * в очередь другая вкладка или следующий старт SDK.
+ *
+ * Пока звонок идёт, вкладка держит замок звонка. Свободный замок значит, что
+ * вкладки больше нет и хвост можно забирать.
+ */
+export declare class CallStatTail {
+    private static _tabId;
+    static get tabId(): string;
+    static lockName(key: string): string;
+    static isSupported(): boolean;
+    private readonly _logger;
+    private readonly _summaries;
+    private readonly _clock;
+    private _status;
+    private _vcid;
+    private _key;
+    /** Первая запись хвоста; null — ещё не было или не удалась */
+    private _creation;
+    private _timer;
+    private _releaseLock;
+    /** Запросы замка подряд, которые закончились без выдачи */
+    private _lockFailures;
+    /** Вызывается, когда хвост забрала другая вкладка */
+    private _onAdopted;
+    /** @param summaries итоги звонка на текущий момент: codec_usage и сводки сигналинга */
+    constructor(logger: StatEventCollector, summaries: () => ClientStatsPayload[], clock?: CallStatTailClock);
+    start(vcid: string, onAdopted: () => void): void;
+    /**
+     * Звонок закончился: снимает хвост и вызывает write, который пишет
+     * настоящий финиш. Если хвост уже забрала другая вкладка, write не
+     * вызывается.
+     */
+    complete(write: () => void): void;
+    private _requestLock;
+    /** Замок держится, пока не разрешён возвращённый промис. */
+    private _onLockGranted;
+    /**
+     * Замок отпустили мы, его отняли (Safari при приостановке страницы) или
+     * не выдали. Отнятый просим снова: пока его нет, хвост может забрать
+     * другая вкладка, и следующая запись это заметит.
+     */
+    private _onLockGone;
+    private _onTimer;
+    /** Первая запись создаёт хвост, остальные обновляют его, только если он ещё лежит. */
+    private _write;
+    private _buildTail;
+    private _collectSummaries;
+    private _adopt;
+    private _finish;
+    private _release;
+    private _clearTimer;
+}

package/classes/stat/ClientResourceStats.d.ts

@@ -0,0 +1,41 @@
+import ActiveFeature from '../../enums/ActiveFeature';
+import { type DebugLogger } from '../../static/Debug';
+/** Метрики ресурсов клиента за интервал между отправками callStat */
+export type ClientResourceReport = {
+    /** Максимум участников за интервал */
+    participants_max?: number;
+    /** Фичи, включенные в любой момент интервала */
+    active_features?: string[];
+    /** Максимальная площадь окна за интервал, в мегапикселях */
+    app_total_area_mpx_max?: number;
+};
+export type ClientResourceSources = {
+    getParticipantsCount: () => number;
+    getActiveFeatures: () => ActiveFeature[];
+};
+/**
+ * Копит ресурсные метрики между отправками callStat: репортер забирает накопленное
+ * через takeReport() и начинает копить заново.
+ *
+ * Замеряем чаще, чем отправляем, потому что нас интересует не состояние в момент отправки,
+ * а что происходило за интервал: пик участников и все фичи, которые успели поработать.
+ */
+export declare class ClientResourceStats {
+    private readonly _sources;
+    private readonly _debug;
+    private _timer;
+    private _participantsMax;
+    private _areaMpxMax;
+    private _features;
+    constructor(sources: ClientResourceSources, debug?: DebugLogger);
+    /** Забрать накопленное за интервал и начать копить заново */
+    takeReport(): ClientResourceReport;
+    destroy(): void;
+    private _sample;
+    /**
+     * Площадь окна в физических пикселях: CSS-пиксели умножаем на devicePixelRatio,
+     * иначе одно и то же окно на экране с ретиной и без давало бы одинаковую цифру.
+     * Приложение в вебе — это одна вкладка, суммировать нечего.
+     */
+    private _measureAreaMpx;
+}

package/classes/stat/CodecStatsAggregator.d.ts

@@ -1,5 +1,5 @@
 import { StatItem } from '../../types/Statistics';
-import StatEventCollector from './StatEventCollector';
+import StatEventCollector, { ClientStatsPayload } from './StatEventCollector';
 import TransportTopology from '../../enums/TransportTopology';
 export type CodecKind = 'audio' | 'video';
 /**
@@ -13,7 +13,10 @@ export declare class CodecStatsAggregator {
     private readonly getCurrentTransportTopology;
     constructor(logger: StatEventCollector, getCurrentTransportTopology: () => TransportTopology | undefined);
     reportUsage(stat: StatItem): void;
+    /** События codec_usage, которые ушли бы сейчас при конце звонка: по текущему кодеку аудио и видео. */
+    usageReports(): ClientStatsPayload[];
     private saveUsage;
     private report;
+    private _toLog;
     destroy(): void;
 }

package/classes/stat/ConversationStats.d.ts

@@ -4,7 +4,9 @@ import TransportTopology from '../../enums/TransportTopology';
 import HangupReason from '../HangupReason';
 import StatEventCollector from './StatEventCollector';
 import { ApiCallStats } from './ApiCallStats';
+import { BatteryStats } from './BatteryStats';
 import { CallLifecycleStats } from './CallLifecycleStats';
+import { ClientResourceSources, ClientResourceStats } from './ClientResourceStats';
 import { CodecStatsAggregator } from './CodecStatsAggregator';
 import { StatAggregator } from './StatAggregator';
 import { StatPings } from './StatPings';
@@ -17,18 +19,21 @@ export declare class ConversationStats {
     readonly pings: StatPings;
     readonly signalingCommands: StatSignalingCommands;
     readonly apiCalls: ApiCallStats;
+    readonly resources: ClientResourceStats;
+    readonly battery: BatteryStats;
     private readonly _api;
-    private _unloading;
-    constructor(api: BaseApi, externalLogger: BaseLogger | null, getConversationId: () => string | null, getTopology: () => TransportTopology | undefined);
+    private readonly _tail;
+    constructor(api: BaseApi, externalLogger: BaseLogger | null, getConversationId: () => string | null, getTopology: () => TransportTopology | undefined, resourceSources: ClientResourceSources);
     /**
-     * Вызывается из pagehide-обработчика: события финиша должны пережить смерть
-     * вкладки. Сводки пингов и команд сбрасываем здесь же — destroy() их только
-     * очищает.
+     * pagehide. С очередью ничего не делаем: финиш и итоги звонка лежат в
+     * хвосте, его перенесёт другая вкладка или следующий старт SDK. Старая
+     * схема отправляет финиш сразу.
      */
-    prepareForUnload(): void;
-    /** Вкладка пережила pagehide: возвращаем запись в очередь. */
-    restoreAfterUnload(): void;
+    onPageHide(): void;
+    resetPingBaseline(): void;
     logHangup(reason: HangupReason): void;
     flushCallMetrics(): void;
     destroy(): void;
+    /** Итоги звонка, которые уйдут в хвосте, если вкладка умрёт посреди звонка. */
+    private _callSummaries;
 }

package/classes/stat/NetworkAdaptationStats.d.ts

@@ -0,0 +1,35 @@
+import { StatAggregator } from './StatAggregator';
+/** Причина события client_requested_server_topology */
+export declare const enum ServerTopologyReason {
+    NO_CONNECTION_TIMEOUT = "no_connection_timeout",
+    CONNECTION_FAILED = "connection_failed",
+    SUCCESS_CONNECTION = "success_connection",
+    /** Возможна на бэке, в вебе пока не поддержана */
+    NO_DATA_TIMEOUT = "no_data_timeout",
+    /** Возможна на бэке, в вебе пока не поддержана */
+    SUCCESS_AUDIO = "success_audio",
+    /** Возможна на бэке, в вебе пока не поддержана */
+    CONNECTION_ACCEPTED_FAILED = "connection_accepted_failed"
+}
+export declare const enum NetworkQuality {
+    GOOD = "good",
+    BAD_1 = "bad_1",
+    BAD_2 = "bad_2"
+}
+export type VideoEncoderChange = {
+    /** Круговая задержка, мс */
+    rtt: number;
+    /** Потери, проценты */
+    loss: number;
+    networkQuality: NetworkQuality;
+    /** mimeType исходящего видео, например video/VP8 */
+    mimeType: string | undefined;
+    source: 'camera' | 'screencast' | 'all';
+};
+/** Отправляет в стату решения клиента по смене топологии и настроек видеоэнкодера */
+export declare class NetworkAdaptationStats {
+    private readonly _statAggregator;
+    constructor(statAggregator: StatAggregator | null);
+    logServerTopologyRequested(reason: ServerTopologyReason, elapsed: number): void;
+    logVideoEncoderChanged(change: VideoEncoderChange): void;
+}

package/classes/stat/PeerConnectionStats.d.ts

@@ -0,0 +1,22 @@
+import { StatAggregator } from './StatAggregator';
+/** Стата жизненного цикла RTCPeerConnection */
+export declare class PeerConnectionStats {
+    private readonly _statAggregator;
+    private _pc;
+    private _lastSignalingStateChange;
+    private _lastGatheringStateChange;
+    private _lastConnectionState;
+    private readonly _handleConnectionStateChange;
+    private readonly _handleSignalingStateChange;
+    private readonly _handleGatheringStateChange;
+    private readonly _handleIceCandidateError;
+    constructor(statAggregator: StatAggregator | null);
+    observe(pc: RTCPeerConnection): void;
+    /** Вызывать перед закрытием соединения: отсюда уходят последнее состояние и closed */
+    stop(): void;
+    logIceRestart(): void;
+    logIceCandidateAddFailed(candidate: RTCIceCandidateInit, error: unknown): void;
+    private _sinceLastChange;
+    private _logConnectionState;
+    private _log;
+}

package/classes/stat/SdpStats.d.ts

@@ -32,8 +32,9 @@ export declare class SdpStats {
     /** Не смогли применить SDP собеседника */
     logSetRemoteFailed(sdp: SdpDescription, error: unknown): void;
     destroy(): void;
-    private _intervalSince;
     private _logFailure;
     private _log;
 }
+/** Браузер может спрятать локальный адрес за именем вида <uuid>.local, такой кандидат в стату не шлём */
+export declare function isIpAddress(address: string): boolean;
 export {};

package/classes/stat/Stat.testUtils.d.ts

@@ -0,0 +1,17 @@
+import type { MockInstance } from 'vitest';
+import { StatTail } from './StatQueue';
+/**
+ * Дожидается работы, которую код запускает в фоне и не отдаёт промис: ждёт всё,
+ * что вернули вызовы шпионов, пока не перестанут появляться новые вызовы.
+ *
+ * Замена опросу vi.waitFor: тот сдаётся через секунду, а IndexedDB на
+ * загруженной машине отвечает дольше. Шпионы должны пропускать вызов к
+ * настоящему методу (vi.spyOn без подмены).
+ */
+export declare function settleCalls(...spies: MockInstance[]): Promise<void>;
+/** Ключ хвоста звонка этой вкладки. */
+export declare function tailKey(vcid: string): string;
+/** Все хвосты звонков на диске. Чтения хвостов у StatQueue нет: таблицу читаем напрямую. */
+export declare function readTails(): Promise<StatTail[]>;
+/** Хвост звонка этой вкладки. */
+export declare function readTail(vcid: string): Promise<StatTail | undefined>;

package/classes/stat/StatAggregator.d.ts

@@ -1,11 +1,13 @@
 import { ICallStatLog } from '../../types/PerfStatReporter';
 import { IEventualStatLog } from '../../types/IEventualStatLog';
 import StatEventCollector from './StatEventCollector';
+import { ClientResourceStats } from './ClientResourceStats';
 export declare class StatAggregator {
     private readonly _logger;
+    private readonly _resources;
     private readonly _eventualLogs;
     private _lastCallStatContext;
-    constructor(logger: StatEventCollector);
+    constructor(logger: StatEventCollector, resources?: ClientResourceStats | null);
     logCallStat(params: ICallStatLog): void;
     /**
      * Событие уходит с теми полями, что переданы. Без value — уходит без value.

package/classes/stat/StatDrainScheduler.d.ts

@@ -9,26 +9,27 @@ export default abstract class StatDrainScheduler {
     private static _state;
     private static _timer;
     private static _localCount;
-    /** Звонок завершился, пока шёл дрейн: его хвост не должен ждать таймаут тишины. */
+    /** Звонок закончился во время отправки: его события уйдут через секунду после неё, а не через 30 с тишины. */
     private static _callFinishedDuringDrain;
     private static _blockedSession;
     /** Буфер прямой отправки: события, которые не легли в хранилище. */
     private static _directBuffer;
     private static _directTimer;
+    private static _tailRecheckTimer;
     static setApi(value: BaseApi): void;
-    /** Первый дрейн подбирает хвосты прошлых сессий и закрытых вкладок. */
+    /** Первая отправка: забирает события, не ушедшие в прошлые запуски, и хвосты звонков закрытых вкладок. */
     static start(value: BaseApi): void;
     /** Вызывается коллектором после записи события в очередь. */
     static notifyAppended(): void;
     /**
-     * Звонок закончился: хвост уходит через секунду, а не через полминуты
-     * тишины. Секунда нужна, чтобы дописались все события финиша.
+     * Звонок закончился: его события уходят через секунду, а не через 30 с
+     * тишины. Секунда нужна, чтобы успели записаться все события конца звонка.
      */
     static notifyCallFinished(): void;
     /**
-     * Один цикл отправки по всем владельцам очереди: текущий — живой сессией,
-     * остальные — сохранённым session_key. Хвост uid X уходит только под
-     * сессией uid X.
+     * Один проход отправки по всем пользователям в очереди: текущий — через
+     * живую сессию, остальные — через сохранённый session_key. События
+     * пользователя X уходят только под сессией X.
      *
      * @returns true, если у кого-то был полный батч и имеет смысл повторить.
      */
@@ -41,12 +42,32 @@ export default abstract class StatDrainScheduler {
      */
     static sendDirect(entry: StatQueueEntry): void;
     private static _currentUserId;
+    private static _firstDrain;
+    /**
+     * Удаляет журналы закрытия вкладки из бет 2.8.13-beta.2…beta.11: читать
+     * их больше некому, а ключи остались бы в localStorage навсегда.
+     *
+     * TODO: удалить через пару релизов после 2.8.13.
+     */
+    private static _removeUnloadJournals;
+    /**
+     * Переносит в очередь хвосты звонков, вкладок которых больше нет:
+     * свободный замок звонка значит, что вкладку закрыли или убили. Если
+     * вкладка жива, проверяем снова через TAIL_RECHECK_DELAY_MS. Иначе
+     * вкладка, которой самой нечего отправлять, забрала бы хвост только при
+     * следующей своей отправке. Вызывается под замком отправки, не бросает.
+     *
+     * @returns число перенесённых хвостов.
+     */
+    private static _adoptCallTails;
+    private static _armTailRecheck;
+    private static _clearTailRecheckTimer;
     /** @returns число записей в батче. */
     private static _drainCurrent;
     /**
-     * Хвост другого пользователя под его сохранённым session_key: одна попытка,
-     * без перелогина. Недоставленное не удаляем — владелец может авторизоваться
-     * в этой вкладке.
+     * События другого пользователя уходят под его сохранённым session_key:
+     * одна попытка, без перелогина. Неотправленное не удаляем, пользователь
+     * может снова войти в этой вкладке.
      *
      * @returns число записей в батче.
      */
@@ -67,13 +88,13 @@ export default abstract class StatDrainScheduler {
     private static _isSessionError;
     /**
      * Транспорт не смог переавторизоваться, чаще всего из-за протухшего
-     * authToken хоста. Хвост не удаляем: он уедет после новой сессии.
+     * authToken хоста. События не удаляем: уйдут после новой сессии.
      */
     private static _isReauthorizeFailure;
     /**
      * Останавливает отправку за текущего пользователя до смены session_key:
-     * другой ключ означает, что авторизация прошла заново. Чужие хвосты не
-     * трогает.
+     * другой ключ означает, что авторизация прошла заново. События других
+     * пользователей не трогает.
      */
     private static _blockSession;
     private static _isSessionBlocked;