@vkontakte/videoplayer-core 2.0.171-dev.881304e5f.0 → 2.0.171-dev.a5a2d3fc3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.171-dev.881304e5f.0",
+  "version": "2.0.171-dev.a5a2d3fc3.0",
   "author": "vk.ru",
   "description": "Videoplayer core library based on the vk.ru platform",
   "homepage": "https://vk.ru",
@@ -42,6 +42,6 @@
     "**/*.d.ts"
   ],
   "dependencies": {
-    "@vkontakte/videoplayer-shared": "1.0.100-dev.881304e5f.0"
+    "@vkontakte/videoplayer-shared": "1.0.100-dev.a5a2d3fc3.0"
   }
 }

package/types/player/types.d.ts

@@ -311,17 +311,29 @@ export interface PlayerInfoValues {
 	*/
 	currentPlaybackRate$: PlaybackRate;
 	/**
-	* Текущий буффер плеера (тот; который содержит текущую позицию воспроизведения)
+	* Текущий видео буффер-плеера (тот; который содержит текущую позицию воспроизведения)
 	*
 	* default value: `undefined`
 	*/
-	currentBuffer$: StartEnd<Seconds> | undefined;
+	currentVideoBuffer$: StartEnd<Seconds> | undefined;
 	/**
-	* Текущий браузерный буффер (тот; который содержит текущую позицию воспроизведения)
+	* Текущий аудио-буффер плеера (тот; который содержит текущую позицию воспроизведения)
 	*
 	* default value: `undefined`
 	*/
-	currentNativeBuffer$: StartEnd<Seconds> | undefined;
+	currentAudioBuffer$: StartEnd<Seconds> | undefined;
+	/**
+	* Текущий браузерный видео-буффер (тот; который содержит текущую позицию воспроизведения)
+	*
+	* default value: `undefined`
+	*/
+	currentNativeVideoBuffer$: StartEnd<Seconds> | undefined;
+	/**
+	* Текущий браузерный аудио-буффер (тот; который содержит текущую позицию воспроизведения)
+	*
+	* default value: `undefined`
+	*/
+	currentNativeAudioBuffer$: StartEnd<Seconds> | undefined;
 	/** Суммарная длительность всех буферизованных диапазонов в миллисекундах */
 	totalBufferDuration$: Milliseconds | undefined;
 	/**

package/types/providers/DashLiveProvider/utils/LiveDashPlayer.d.ts

@@ -49,8 +49,9 @@ export default class LiveDashPlayer {
 	private bufferStates;
 	private downloadRate?;
 	private sourceJitter;
-	/** Токен для защиты от устаревших callback'ов sourceopen при многократных вызовах _setVideoSrc */
 	private srcToken;
+	private videoListeners;
+	private objectUrl;
 	private chunkRateEstimator;
 	private manifestUrl;
 	private urlResolver;

package/types/providers/DashProvider/lib/buffer.d.ts

@@ -41,6 +41,7 @@ export declare class BufferManager {
 	private parsedInitData;
 	private representations;
 	private segments;
+	private segmentIndexMap;
 	private allInitsLoaded;
 	private activeSegments;
 	private forwardBufferRepresentations;
@@ -75,6 +76,7 @@ export declare class BufferManager {
 	private lastDataObtainedTimestampMs;
 	private loadByteRangeSegmentsTimeoutId;
 	private preDownloadedFirstSegment;
+	private brokenSegmentAppendDetected;
 	constructor(kind: StreamKind, mediaSource: MediaSource, representations: Representation[], { fetcher, tuning, getCurrentPosition, isActiveLowLatency, compatibilityMode, manifest }: Dependencies);
 	startWith: ReturnType<typeof abortable<[Representation["id"]]>>;
 	switchToWithPreviousAbort(newRepresentationId: Representation["id"], dropBuffer?: boolean): Promise<void | undefined>;
@@ -106,6 +108,7 @@ export declare class BufferManager {
 	private feedPreDownloadedFirstSegment;
 	private loadByteRangeSegments;
 	private prepareByteRangeFetchSegmentParams;
+	private buildCacheMetadata;
 	private prepareTemplateFetchSegmentParams;
 	private abortActiveSegments;
 	private onSomeTemplateDataLoaded;
@@ -119,6 +122,7 @@ export declare class BufferManager {
 	*/
 	private onSomeByteRangesDataLoaded;
 	private onSegmentFullyAppended;
+	private detectBrokenSegmentAppend;
 	private abortSegment;
 	private loadNextInit;
 	private loadInit;

package/types/providers/DashProvider/lib/fetcher.d.ts

@@ -4,6 +4,7 @@ import type { Byte, IValueSubject, ISubject, Milliseconds, IRange, ITracer, IErr
 import { abortable } from "@vkontakte/videoplayer-shared";
 import type { ExactVideoQuality } from "@vkontakte/videoplayer-shared";
 import type { CommonInit, GenericContainerParser, Segment, SegmentReference } from "../../utils/parsers/types";
+import type { ISegmentCacheStorage, CacheMetadata } from "../../utils/segmentCache";
 declare global {
 	interface Navigator {
 		connection: {
@@ -24,11 +25,11 @@ export interface IParams {
 	tracer: ITracer;
 	useEnableSubtitlesParam?: boolean;
 	handleExtendedNetworkErrorsSet?: boolean;
-	useUrlCacheMechanism?: boolean;
 	measureNonSegmentRequests?: boolean;
 	measureFastSamples?: boolean;
 	preloadFirstSegment?: boolean;
 	maxQualityForFirstSegmentPreload?: ExactVideoQuality;
+	segmentCacheService?: ISegmentCacheStorage;
 }
 export type Priority = "high" | "low" | "auto";
 export interface FetchParamsWithUrl extends FetchParams {
@@ -45,8 +46,8 @@ export interface FetchParams {
 	isLowLatency?: boolean;
 	bufferOptimisation?: boolean;
 	ignoreNetworkErrors?: boolean;
-	urlCacheMechanismEnabled?: boolean;
 	representationHeight?: number;
+	cacheMetadata?: CacheMetadata;
 }
 export type RepresentationFetchResult = {
 	init: CommonInit | null;
@@ -73,16 +74,17 @@ export declare class Fetcher {
 	private readonly subscription;
 	private compatibilityMode;
 	private useEnableSubtitlesParam;
-	private useUrlCacheMechanism;
 	private measureNonSegmentRequests;
 	private measureFastSamples;
 	private preloadFirstSegment;
 	private maxQualityForFirstSegmentPreload;
+	private segmentCacheService;
+	private segmentCache;
 	private startupPhase;
 	private performanceObserver;
 	private pendingConnectionMetrics;
 	private handleExtendedNetworkErrorsSet;
-	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, useUrlCacheMechanism, measureNonSegmentRequests, measureFastSamples, preloadFirstSegment, maxQualityForFirstSegmentPreload }: IParams);
+	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, measureNonSegmentRequests, measureFastSamples, preloadFirstSegment, maxQualityForFirstSegmentPreload, segmentCacheService }: IParams);
 	private onHeadersReceived;
 	private setupPerformanceObserver;
 	private processPerformanceResourceTiming;

package/types/providers/DashProvider/lib/player.d.ts

@@ -40,6 +40,7 @@ export declare class Player {
 	private subscriptionRemovable;
 	private representationSubscription;
 	private fetcher;
+	private segmentCacheService;
 	state$: StateMachine<State>;
 	currentVideoRepresentation$: IValueSubject<Representation["id"] | undefined>;
 	currentVideoRepresentationInit$: IValueSubject<CommonInit | undefined>;

package/types/providers/DashProviderVirtual/lib/buffer/types.d.ts

@@ -3,6 +3,7 @@ import type { CommonInit, Manifest, Representation, Segment } from "../../../uti
 import type { Fetcher } from "../fetcher";
 import type { ITuningConfig } from "../../../../utils/tuningConfig";
 import type { VideoSegmentLoadProgress } from "../../../utils/Abr/types";
+import type { ISegmentCacheStorage } from "../../../utils/segmentCache";
 export type TRepresentationSwitchMode = "lazy" | "force";
 export declare enum SwithRepresentationMode {
 	Lazy = "lazy",
@@ -15,6 +16,7 @@ export interface Dependencies {
 	tuning: ITuningConfig;
 	compatibilityMode?: boolean;
 	manifest: Manifest | null;
+	segmentCacheService?: ISegmentCacheStorage;
 	getCurrentPosition(): Milliseconds | undefined;
 	getCurrentStallDuration(): Milliseconds;
 	isActiveLowLatency(): boolean;

package/types/providers/DashProviderVirtual/lib/buffer/virtualBuffer/baseVirtualBufferManager.versionA.d.ts

@@ -2,6 +2,7 @@ import type { Fetcher, FetchParamsWithUrl, Priority, RepresentationFetchResult }
 import type { CommonInit, ContainerParser, Representation, Segment } from "../../../../utils/parsers/types";
 import { StreamKind } from "../../../../utils/parsers/types";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+import type { ISegmentCacheStorage } from "../../../../utils/segmentCache";
 import type { Byte, IError, IRange, ISubject, ITracer, IValueSubject, Milliseconds, Seconds } from "@vkontakte/videoplayer-shared";
 import { abortable, Subscription } from "@vkontakte/videoplayer-shared";
 import type { NativeBufferManager } from "../nativeBufferManager";
@@ -19,6 +20,7 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected readonly fetcher: Fetcher;
 	protected readonly tracer: ITracer;
 	protected readonly tuning: ITuningConfig;
+	protected readonly segmentCacheService: ISegmentCacheStorage | undefined;
 	protected representations: Map<Representation["id"], Representation>;
 	protected playingRepresentationId: Representation["id"] | undefined;
 	protected downloadingRepresentationId: Representation["id"] | undefined;
@@ -52,7 +54,8 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected subscription: Subscription;
 	protected readonly getCurrentPosition: () => Milliseconds | undefined;
 	protected readonly getCurrentStallDuration: () => Milliseconds | undefined;
-	protected constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], { fetcher, tracer, tuning, getCurrentPosition, getCurrentStallDuration, manifest }: Dependencies);
+	protected brokenSegmentAppendDetected: boolean;
+	protected constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], { fetcher, tracer, tuning, getCurrentPosition, getCurrentStallDuration, manifest, segmentCacheService }: Dependencies);
 	protected abstract loadItems(itemsToLoad: IBufferPlaybackQueueItem<T>[], representation: Representation, priority?: Priority): Promise<void>;
 	protected abstract selectItemsToLoad(): IBufferPlaybackQueueItem<T>[];
 	protected abstract prepareFetchParams(items: IBufferPlaybackQueueItem<T>[], representation: Representation): FetchParamsWithUrl;
@@ -120,6 +123,7 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected parseFeedableSegmentChunk(chunk: DataView): DataView | null;
 	protected onItemFullyDownloaded(downloadedItem: IBufferPlaybackQueueItem<T>): void;
 	protected onItemFullyAppended(appendedItem: IBufferPlaybackQueueItem<T>): void;
+	private detectBrokenSegmentAppend;
 	protected removeSegment(nextRemoveItem: IBufferPlaybackQueueItem<T>, signal: AbortSignal): Promise<void>;
 	protected onDownloadItem(downloadedItem: IBufferPlaybackQueueItem<T>): void;
 	protected pruneVirtualBuffer(currentPosition: Milliseconds): void;

package/types/providers/DashProviderVirtual/lib/buffer/virtualBuffer/byteRangeVirtualBufferManager.versionA.d.ts

@@ -8,6 +8,7 @@ export declare class ByteRangeVirtualBufferManager extends BaseVirtualBufferMana
 	protected override loadItems(itemsToLoad: IBufferPlaybackQueueItem<ByteRangeSegment>[], representation: Representation, priority?: Priority): Promise<void>;
 	protected override selectItemsToLoad(): IBufferPlaybackQueueItem<ByteRangeSegment>[];
 	protected override prepareFetchParams(items: IBufferPlaybackQueueItem<ByteRangeSegment>[], representation: Representation): FetchParamsWithUrl;
+	private buildCacheMetadata;
 	/**
 	* Закидываем в буфер сегменты атомарнее чем сегмент целиком. Например, по боксам в мпеге и по блокам в вебме.
 	* Таким образом не ждём его полной загрузки и готовы играть его намного быстрее

package/types/providers/DashProviderVirtual/lib/fetcher.d.ts

@@ -4,6 +4,7 @@ import type { Byte, IError, IRange, ISubject, ITracer, IValueSubject, Millisecon
 import { abortable } from "@vkontakte/videoplayer-shared";
 import type { ExactVideoQuality } from "@vkontakte/videoplayer-shared";
 import type { CommonInit, GenericContainerParser, Segment, SegmentReference, StreamKind } from "../../utils/parsers/types";
+import type { ISegmentCacheStorage, CacheMetadata } from "../../utils/segmentCache";
 declare global {
 	interface Navigator {
 		connection: {
@@ -24,11 +25,11 @@ export interface IParams {
 	tracer: ITracer;
 	useEnableSubtitlesParam?: boolean;
 	handleExtendedNetworkErrorsSet?: boolean;
-	useUrlCacheMechanism?: boolean;
 	measureNonSegmentRequests?: boolean;
 	measureFastSamples?: boolean;
 	preloadFirstSegment?: boolean;
 	maxQualityForFirstSegmentPreload?: ExactVideoQuality;
+	segmentCacheService?: ISegmentCacheStorage;
 }
 export type Priority = "high" | "low" | "auto";
 export interface FetchParamsWithUrl extends FetchParams {
@@ -44,8 +45,8 @@ export interface FetchParams {
 	measureThroughput?: boolean;
 	isLowLatency?: boolean;
 	bufferOptimisation?: boolean;
-	urlCacheMechanismEnabled?: boolean;
 	kind: StreamKind;
+	cacheMetadata?: CacheMetadata;
 }
 export type RepresentationFetchResult<T extends Segment> = {
 	initMetadata: CommonInit | null;
@@ -72,16 +73,17 @@ export declare class Fetcher {
 	private subscription;
 	private compatibilityMode;
 	private useEnableSubtitlesParam;
-	private useUrlCacheMechanism;
 	private measureNonSegmentRequests;
 	private measureFastSamples;
 	private preloadFirstSegment;
 	private maxQualityForFirstSegmentPreload;
+	private segmentCacheService;
+	private segmentCache;
 	private startupPhase;
 	private performanceObserver;
 	private pendingConnectionMetrics;
 	private handleExtendedNetworkErrorsSet;
-	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, useUrlCacheMechanism, measureNonSegmentRequests, measureFastSamples, preloadFirstSegment, maxQualityForFirstSegmentPreload }: IParams);
+	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, measureNonSegmentRequests, measureFastSamples, preloadFirstSegment, maxQualityForFirstSegmentPreload, segmentCacheService }: IParams);
 	private onHeadersReceived;
 	private setupPerformanceObserver;
 	private processResourceTiming;

package/types/providers/DashProviderVirtual/lib/player/basePlayer.d.ts

@@ -9,6 +9,7 @@ import type { IError, IRange, ISubject, ISubscription, ITracer, IValueSubject, M
 import { abortable, Subject, Subscription, SubscriptionRemovable } from "@vkontakte/videoplayer-shared";
 import type { VideoSegmentLoadProgress } from "../../../utils/Abr/types";
 import { Fetcher } from "../fetcher";
+import type { ISegmentCacheStorage } from "../../../utils/segmentCache";
 import type { Dependencies, IVirtualBufferManager, SwithRepresentationMode } from "../buffer/types";
 import type { Params } from "./types";
 import { State } from "./types";
@@ -35,6 +36,7 @@ export declare abstract class BasePlayer {
 	protected subscriptionRemovable: SubscriptionRemovable;
 	protected representationSubscription: Subscription;
 	protected fetcher: Fetcher;
+	protected segmentCacheService: ISegmentCacheStorage | undefined;
 	protected forceEnded$: ISubject<void>;
 	protected stallWatchdogSubscription: ISubscription | undefined;
 	protected destroyController: AbortController;
@@ -63,9 +65,11 @@ export declare abstract class BasePlayer {
 	liveSeekableDuration$: IValueSubject<Milliseconds>;
 	liveAvailabilityStartTime$: IValueSubject<Milliseconds>;
 	liveStreamStatus$: IValueSubject<LiveStreamStatus | undefined>;
-	currentBuffer$: IValueSubject<IRange<Seconds>>;
+	currentVideoBuffer$: IValueSubject<IRange<Seconds>>;
+	currentAudioBuffer$: IValueSubject<IRange<Seconds>>;
 	bufferLength$: IValueSubject<Milliseconds>;
 	nativeBufferLength$: IValueSubject<Milliseconds>;
+	nativeAudioBufferLength$: IValueSubject<IRange<Seconds>>;
 	liveLatency$: IValueSubject<Milliseconds | undefined>;
 	liveLoadBufferLength$: IValueSubject<Milliseconds>;
 	livePositionFromPlayer$: IValueSubject<number>;

package/types/providers/ProviderContainer/Mayday/GraceTimeout.d.ts

@@ -0,0 +1,17 @@
+import type { Milliseconds } from "@vkontakte/videoplayer-shared";
+/**
+* Декрементный grace-таймаут: каждый вызов `decay()` уменьшает оставшееся время.
+*
+* После создания `current` возвращает начальное значение.
+* Каждый вызов `decay()` умножает `remaining` на `decayFactor`, но не меньше `minTimeout`.
+* Когда `remaining` достигает `minTimeout` — следующий `decay()` возвращает 0 (expire).
+*/
+export declare class GraceTimeout {
+	private remaining;
+	private readonly decayFactor;
+	private readonly minTimeout;
+	constructor(initialTimeout: Milliseconds, decayFactor: number, minTimeout: Milliseconds);
+	get current(): Milliseconds;
+	decay(): Milliseconds;
+	reset(initialTimeout: Milliseconds): void;
+}

package/types/providers/ProviderContainer/Mayday/heuristics/SegmentAppendHeuristic.d.ts

@@ -0,0 +1,10 @@
+import type { IError } from "@vkontakte/videoplayer-shared";
+import type { IHeuristicDeps } from "../types";
+import type { ISyncHeuristic, HeuristicResult } from "./IHeuristic";
+export declare class SegmentAppendHeuristic implements ISyncHeuristic {
+	private deps;
+	static readonly heuristicName = "SegmentAppendHeuristic";
+	readonly type = "sync";
+	constructor(deps: IHeuristicDeps);
+	analyze(error: IError): HeuristicResult;
+}

package/types/providers/ProviderContainer/Mayday/heuristics/StartupHangupHeuristic.d.ts

@@ -0,0 +1,46 @@
+import { Subject } from "@vkontakte/videoplayer-shared";
+import type { IError } from "@vkontakte/videoplayer-shared";
+import type { IHeuristicDeps, IMaydayEvent } from "../types";
+import type { IAsyncHeuristic, HeuristicResult } from "./IHeuristic";
+/**
+* Эвристика зависания перехода stopped-*.
+*
+* В зависимости от видимости вкладки и наличия звука выбирает стратегию
+* и эмитит одну из рекомендаций:
+*
+* Visible-вкладка: grace-таймаут с уменьшением таймаута на поступление данных.
+*   — данные поступают → таймер продлевается.
+*   — grace истёк без прогресса → emit switch_codec (или switch_provider).
+*
+* Hidden-вкладка (audible): та же grace-модель с таймаутом (таймеры в воркере не тротлятся).
+*   — данные поступают → таймер продлевается.
+*   — grace истёк без прогресса → emit switch_codec.
+*
+* Hidden-вкладка (muted/deferred): молча ждём возврата на visible, desired state не трогаем.
+*   — вкладка стала visible → emit reinit (полный реинит сам восстановит воспроизведение).
+*   — переход всё-таки завершился в фоне (видео заиграло) → отмена, reinit не нужен.
+*/
+export declare class StartupHangupHeuristic implements IAsyncHeuristic {
+	private deps;
+	static readonly heuristicName = "StartupHangupHeuristic";
+	readonly type = "async";
+	readonly recommendation$: Subject<IMaydayEvent>;
+	private timerId;
+	private subscription;
+	private error;
+	private grace;
+	private hangupStartedAt;
+	private dataArrivals;
+	private hiddenWaitActive;
+	constructor(deps: IHeuristicDeps);
+	analyze(error: IError): HeuristicResult;
+	private startMonitoring;
+	private waitForVisible;
+	private restartTimer;
+	private recommendSwitch;
+	private isTabHidden;
+	private logOutcome;
+	private cancel;
+	reset(): void;
+	destroy(): void;
+}

package/types/providers/ProviderContainer/Mayday/index.d.ts

@@ -4,5 +4,5 @@ export type { ISyncHeuristic, IAsyncHeuristic, HeuristicResult } from "./heurist
 export { MediaErrorHeuristic } from "./heuristics/MediaErrorHeuristic";
 export { FetcherErrorHeuristic } from "./heuristics/FetcherErrorHeuristic";
 export { TvFetcherErrorHeuristic } from "./heuristics/TvFetcherErrorHeuristic";
-export { HangupHeuristic } from "./heuristics/HangupHeuristic";
+export { StartupHangupHeuristic } from "./heuristics/StartupHangupHeuristic";
 export { MaydayStatistics } from "./MaydayStatistics";

package/types/providers/ProviderContainer/Mayday/types.d.ts

@@ -14,7 +14,7 @@ export interface IMaydayProviderOutput {
 	position$: IValueSubject<number>;
 	currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
 	totalBufferDuration$: IValueSubject<Milliseconds | undefined>;
-	currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	currentNativeVideoBuffer$: IValueSubject<IRange<Seconds> | undefined>;
 	bufferRangeCount$: IValueSubject<number | undefined>;
 	availableVideoStreams$: IValueSubject<IVideoStream[]>;
 	currentAudioStream$: IValueSubject<IAudioStream | undefined>;
@@ -54,6 +54,7 @@ export interface IHeuristicDeps {
 	getVisibilityState: () => DocumentVisibilityState | undefined;
 	getReadyState: () => number | undefined;
 	getVideoPaused: () => boolean | undefined;
+	getIsMuted: () => boolean;
 	currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
 	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds | undefined>;
 	desiredPlaybackState$: IStateMachine<PlaybackState>;

package/types/providers/ProviderContainer/index.d.ts

@@ -37,6 +37,7 @@ export default class ProviderContainer implements IProviderContainer {
 	private currentProviderStarted;
 	private volumeMultiplierManager;
 	private dashMaxTvVideoQuality;
+	private segmentCacheCleared;
 	private mayday;
 	private maydayStatistics;
 	constructor(params: IParams);
@@ -50,6 +51,8 @@ export default class ProviderContainer implements IProviderContainer {
 	private destroyProvider;
 	private handleMaydayRecommendation;
 	private applyErrorSideEffects;
+	/** Битые данные в кэше могут вызывать повторные ошибки после реинита — очищаем кэш целиком. */
+	private clearSegmentCacheOnError;
 	private createProvider;
 	private createScreenProvider;
 	private createChromecastProvider;

package/types/providers/ProviderContainer/utils/playbackHangup.d.ts

@@ -1,6 +1,5 @@
 import type { IProviderEntry } from "../types";
 import type { IObservable, Milliseconds } from "@vkontakte/videoplayer-shared";
-import { Observable } from "@vkontakte/videoplayer-shared";
 import type { IStateMachine } from "../../../utils/StateMachine/types";
 import { PlaybackState } from "../../../player/types";
 interface IParams {
@@ -12,5 +11,10 @@ interface IParams {
 	playbackHangupNoDataThreshold: Milliseconds;
 	useDelayedPlaybackHangupWithData: boolean;
 }
-declare const _default: (params: IParams) => Observable<string>;
+export interface IPlaybackHangupInfo {
+	from: PlaybackState;
+	to: PlaybackState;
+	label: string;
+}
+declare const _default: (params: IParams) => IObservable<IPlaybackHangupInfo>;
 export default _default;

package/types/providers/types.d.ts

@@ -81,8 +81,10 @@ export interface IProviderOutput {
 	autoVideoTrackLimits$: IValueSubject<QualityLimits | undefined>;
 	autoVideoTrackLimitingAvailable$: IValueSubject<boolean>;
 	canChangePlaybackSpeed$: IValueSubject<boolean | undefined>;
-	currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
-	currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	currentVideoBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	currentAudioBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	currentNativeVideoBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	currentNativeAudioBuffer$: IValueSubject<IRange<Seconds> | undefined>;
 	totalBufferDuration$: IValueSubject<Milliseconds | undefined>;
 	bufferRangeCount$: IValueSubject<number | undefined>;
 	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds | undefined>;

package/types/providers/utils/Abr/abrController.d.ts

@@ -1,5 +1,6 @@
-import type { IAbrController, IAbrRule, IBaseAbrControllerContext, IRuleInitContext } from "./types";
+import type { IAbrController, IAbrRule, IBaseAbrControllerContext, IRuleInitContext, RuleLogData } from "./types";
 import type { IBaseTrack } from "../../../player/types";
+export declare const formatRuleLog: ({ name, ...logData }: RuleLogData) => string;
 export default class AbrController<
 	T extends IBaseTrack,
 	C extends IBaseAbrControllerContext
@@ -12,6 +13,8 @@ export default class AbrController<
 	destroy(): void;
 	updateContext(context: C): void;
 	autoSelectTrack(rules?: IAbrRule<T, C>[]): T;
+	private traceQualitySwitch;
+	private isLowQuality;
 	private selectTrackBasedOnHistory;
 	/** при переключении аудио стрима очищаем историю для предотвращения залипания в `onCooldown` */
 	historyReset(): void;

package/types/providers/utils/Abr/abrManager.d.ts

@@ -10,6 +10,7 @@ export declare class AbrManager {
 	private context;
 	private phaseController;
 	private allVideoRules;
+	private tracer;
 	init(context: IInitAbrManagerContext): void;
 	updateContext(updateContext: IUpdatableAbrManagerContext): void;
 	autoSelectTrack<T extends IVideoTrack | IAudioTrack>(kind: Exclude<StreamKind, StreamKind.TEXT>): T;

package/types/providers/utils/Abr/controllers/stallsController.d.ts

@@ -1,4 +1,4 @@
-import type { IObservable, IValueSubject, Milliseconds } from "@vkontakte/videoplayer-shared";
+import type { IObservable, ITracer, IValueSubject, Milliseconds } from "@vkontakte/videoplayer-shared";
 import type { ITuningConfig } from "../../../../utils/tuningConfig";
 import type { IVideoTrack } from "../../../../player/types";
 import type { IObservableVideo } from "../../HTMLVideoElement/observable";
@@ -10,6 +10,7 @@ interface IConnectData {
 	observableVideo: IObservableVideo;
 	currentStallDuration$: IValueSubject<Milliseconds>;
 	tuning: ITuningConfig["stallsManager"];
+	tracer: ITracer;
 }
 export declare class StallsController {
 	private currentStallDuration$;
@@ -20,6 +21,9 @@ export declare class StallsController {
 	private lastUniqueVideoTrackSelectedTimestamp;
 	private lastUniqueVideoTrackSelected;
 	private providerStartWatchingTimestamp;
+	private tracer;
+	private severeStallTracer;
+	private severeStallStartedAt;
 	private subscription;
 	severeStallOccurred$: IValueSubject<boolean>;
 	totalStallsCount$: IValueSubject<number>;
@@ -28,6 +32,9 @@ export declare class StallsController {
 	lastStallDuration$: IValueSubject<Milliseconds>;
 	init(data: IConnectData): void;
 	destroy(): void;
+	private startSevereStallTracer;
+	private endSevereStallTracer;
+	private traceUpdateStallData;
 	private updateStallData;
 }
 export {};

package/types/providers/utils/Abr/rules/audio/audioThroughputRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext, RuleLogData } from "../../types";
 import type { IAudioTrack, IVideoTrack } from "../../../../../player/types";
 import { LimitAboveRule } from "../limitAboveRule";
 import type { Kbps, Nullable } from "@vkontakte/videoplayer-shared";
@@ -8,6 +8,6 @@ type AudioThroughputLogsArgs = [forwardBufferHealth: Nullable<number>, playbackR
 export declare class AudioThroughputRule extends LimitAboveRule<IAudioTrack, IAudioAbrContext, AudioThroughputLogsArgs> implements IAbrRule<IAudioTrack, IAudioAbrContext> {
 	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IAudioAbrContext): IAbrRuleResolution<IAudioTrack>;
-	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferHealth: number | undefined, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig): string;
+	protected createLogData(selectedTrack: IVideoTrack, forwardBufferHealth: number | undefined, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig): RuleLogData;
 }
 export {};

package/types/providers/utils/Abr/rules/audio/minAudioForVideoRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext, RuleLogData } from "../../types";
 import type { IAudioTrack, IVideoTrack } from "../../../../../player/types";
 import { LimitBelowRule } from "../limitBelowRule";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
@@ -8,6 +8,6 @@ type MinAudioForVideoLogsArgs = [lastVideoTrackSelected: Nullable<IVideoTrack>,
 export declare class MinAudioForVideoRule extends LimitBelowRule<IAudioTrack, IAudioAbrContext, MinAudioForVideoLogsArgs> implements IAbrRule<IAudioTrack, IAudioAbrContext> {
 	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IAudioAbrContext): IAbrRuleResolution<IAudioTrack>;
-	protected createLogMessage(selectedTrack: IVideoTrack, lastVideoTrackSelected: Nullable<IVideoTrack>, tuning: ITuningConfig): string;
+	protected createLogData(selectedTrack: IVideoTrack, lastVideoTrackSelected: Nullable<IVideoTrack>, tuning: ITuningConfig): RuleLogData;
 }
 export {};

package/types/providers/utils/Abr/rules/baseRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, IRuleInitContext, RuleConfidence, RuleType } from "../types";
+import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, IRuleInitContext, RuleConfidence, RuleLogData, RuleType } from "../types";
 import type { IBaseTrack } from "../../../../player/types";
 import { Subscription } from "@vkontakte/videoplayer-shared";
 import type { AbrPhase } from "../controllers/abrPhaseController";
@@ -19,5 +19,5 @@ export declare abstract class BaseRule<
 	destroy(): void;
 	abstract execute(context: C): IAbrRuleResolution<T>;
 	protected createResolution(context: C, selectedTrack: T, ...params: LogsArgs): IAbrRuleResolution<T>;
-	protected abstract createLogMessage(selectedTrack: T, ...params: LogsArgs): string;
+	protected abstract createLogData(selectedTrack: T, ...params: LogsArgs): RuleLogData;
 }

package/types/providers/utils/Abr/rules/video/abandonRequestRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleLogData } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Milliseconds } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
@@ -7,6 +7,6 @@ type LogsArgs = [elapsedMs: Milliseconds, loadedFraction: number, estimatedRemai
 export declare class AbandonRequestRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, LogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
 	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
-	protected createLogMessage(selectedTrack: IVideoTrack, elapsedMs: Milliseconds, loadedFraction: number, estimatedRemainingMs: Milliseconds, bufferLimitMs: Milliseconds, triggered: boolean): string;
+	protected createLogData(selectedTrack: IVideoTrack, elapsedMs: Milliseconds, loadedFraction: number, estimatedRemainingMs: Milliseconds, bufferLimitMs: Milliseconds, triggered: boolean): RuleLogData;
 }
 export {};

package/types/providers/utils/Abr/rules/video/bolaRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, IVideoAbrContext } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, IVideoAbrContext, RuleLogData } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Kbps, Seconds } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
@@ -26,6 +26,6 @@ export declare class BolaRule extends LimitAboveRule<IVideoTrack, IVideoAbrConte
 	private resolveSegmentDurationS;
 	private applyBolaOSafeguard;
 	private resetPlaceholder;
-	protected createLogMessage(selectedTrack: IVideoTrack, bufferLevelS: Seconds, placeholderBufferS: Seconds, segmentDurationS: Seconds, Vp: number, gp: number, validBitrates: Kbps[], selectedIndex: number, phase: AbrPhase | undefined): string;
+	protected createLogData(selectedTrack: IVideoTrack, bufferLevelS: Seconds, placeholderBufferS: Seconds, segmentDurationS: Seconds, Vp: number, gp: number, validBitrates: Kbps[], selectedIndex: number, phase: AbrPhase | undefined): RuleLogData;
 }
 export {};

package/types/providers/utils/Abr/rules/video/bufferRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleLogData } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Nullable } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
@@ -12,6 +12,6 @@ type BufferRuleLogsArgs = [currentVideoTrack: Nullable<IVideoTrack>, lastVideoTr
 export declare class BufferRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, BufferRuleLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
 	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
-	protected createLogMessage(selectedTrack: IVideoTrack, currentVideoTrack: Nullable<IVideoTrack>, lastVideoTrackSelected: Nullable<IVideoTrack>, forwardBufferHealth: Nullable<number>, abrTuning: ITuningConfig["autoTrackSelection"]): string;
+	protected createLogData(selectedTrack: IVideoTrack, currentVideoTrack: Nullable<IVideoTrack>, lastVideoTrackSelected: Nullable<IVideoTrack>, forwardBufferHealth: Nullable<number>, abrTuning: ITuningConfig["autoTrackSelection"]): RuleLogData;
 }
 export {};

package/types/providers/utils/Abr/rules/video/fitsContainerRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleLogData } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { IRectangle, Nullable } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
@@ -9,7 +9,7 @@ type FitsContainerLogsArgs = [containerSizeLimit: Nullable<IContainerSizeLimit>,
 export declare class FitsContainerRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, FitsContainerLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
 	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
-	protected createLogMessage(selectedTrack: IVideoTrack, containerSizeLimit: Nullable<IContainerSizeLimit>, containerSizeFactor: number, abrTuning: ITuningConfig["autoTrackSelection"]): string;
+	protected createLogData(selectedTrack: IVideoTrack, containerSizeLimit: Nullable<IContainerSizeLimit>, containerSizeFactor: number, abrTuning: ITuningConfig["autoTrackSelection"]): RuleLogData;
 	private getContainerSizeLimit;
 }
 export {};

package/types/providers/utils/Abr/rules/video/insufficientBufferRule.d.ts

@@ -1,4 +1,4 @@
-import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, IVideoAbrContext } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, IVideoAbrContext, RuleLogData } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Milliseconds } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
@@ -10,6 +10,6 @@ export declare class InsufficientBufferRule extends LimitAboveRule<IVideoTrack,
 	override init(initContext: IRuleInitContext): void;
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
 	private selectThroughputAwareFallback;
-	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferDuration: Milliseconds | undefined, thresholdMs: Milliseconds, triggered: boolean, suppressedByGrace: boolean): string;
+	protected createLogData(selectedTrack: IVideoTrack, forwardBufferDuration: Milliseconds | undefined, thresholdMs: Milliseconds, triggered: boolean, suppressedByGrace: boolean): RuleLogData;
 }
 export {};