@vkontakte/videoplayer-core 2.0.161 → 2.0.162-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.161",
+  "version": "2.0.162-beta.1",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",
@@ -42,6 +42,6 @@
     "**/*.d.ts"
   ],
   "dependencies": {
-    "@vkontakte/videoplayer-shared": "1.0.90"
+    "@vkontakte/videoplayer-shared": "1.0.91-beta.1"
   }
 }

package/types/index.d.ts

@@ -1,6 +1,7 @@
 import { VERSION } from "./env";
 import type { IMpegSource, IDashSource, IHLSSource, IDashURLSource, IHLSLiveSource, ISeekRequest, URLSource, RawSource, URLSourceWithSeek } from "./player/types";
-import { VideoFormat, Surface, PredefinedQualityLimits, VideoCodec } from "./player/types";
+import type { VideoCodec } from "./player/types";
+import { VideoFormat, Surface, PredefinedQualityLimits, VideoCodecName } from "./player/types";
 import Player from "./player/Player";
 import type { IPlayer, IPlayerInfo, IPlayerEvents, IConfig, ISources, ICueSettings, IExternalTextTrack, ITextTrack, PlaybackRate, IVideoStream, IAudioStream } from "./player/types";
 import { PlaybackState, ChromecastState, HttpConnectionType } from "./player/types";
@@ -15,4 +16,4 @@ import { Subscription, Observable, Subject, ValueSubject, VideoQuality } from "@
 */
 declare const SDK_VERSION: string;
 export type { IPlayer, IPlayerInfo, IPlayerEvents, IConfig, IOptionalTuningConfig, ILogEntry, ISources, IExternalTextTrack, ITextTrack, ISubscription, IUnsubscriber, IObservable, IEmitter, IValueObservable, IValue, IOperator, IListener, IMpegSource, IDashSource, IDashURLSource, IHLSSource, IHLSLiveSource, URLSource, RawSource, URLSourceWithSeek, ExactVideoQuality, IRange, ISeekRequest, ICueSettings, PlaybackRate, IVideoStream, IAudioStream };
-export { Player, PlaybackState, ChromecastState, HttpConnectionType, Surface, Subscription, VideoFormat, VideoQuality, Observable, Subject, ValueSubject, VERSION, SDK_VERSION, PredefinedQualityLimits, VideoCodec };
+export { Player, PlaybackState, ChromecastState, HttpConnectionType, Surface, Subscription, VideoFormat, VideoQuality, Observable, Subject, ValueSubject, VERSION, SDK_VERSION, PredefinedQualityLimits, VideoCodec, VideoCodecName };

package/types/player/types.d.ts

@@ -326,10 +326,12 @@ export interface PlayerInfoValues {
 	*/
 	isBuffering$: boolean;
 	/**
-	* Статус только нежелательной буферизации; возникает при опустошении буфера в процессе воспроизведения
+	* Состояние столла. Возникает по истечении stallIgnoreThreshold после старта нежелательной буферизации
+	* Статус только нежелательной буферизации возникает при опустошении буфера в процессе воспроизведения
 	* и не возникает при начальном наполнении буфера или после перемотки
 	*/
 	isStalled$: boolean;
+	stallStartTime$: Milliseconds;
 	/**
 	* Закончилось ли видео
 	*/
@@ -532,6 +534,10 @@ export interface IConfig {
 	volumeMultiplier?: number;
 	panelSize?: IRectangle;
 	isMuted?: boolean;
+	/**
+	* Нужно ли recoverableError обрабатывать как ошибку провайдера или будет снаружи обрабатываться.
+	*/
+	handleNetworkRecoverableErrorAsProviderError?: boolean;
 }
 export interface ISources {
 	[VideoFormat.MPEG]?: IMpegSource;
@@ -599,12 +605,16 @@ export declare enum VideoFormat {
 	HLS_LIVE_CMAF = "HLS_LIVE_CMAF",
 	WEB_RTC_LIVE = "WEB_RTC_LIVE"
 }
-export declare enum VideoCodec {
+export declare enum VideoCodecName {
 	AV1 = "av1",
 	VP9 = "vp9",
 	AVC1 = "avc1",
 	HEV1 = "hev1"
 }
+export interface VideoCodec {
+	name: VideoCodecName;
+	hdr: boolean;
+}
 export declare enum AudioCodec {
 	OPUS = "opus",
 	MP4A = "mp4a"
@@ -633,6 +643,7 @@ export interface IAudioStream {
 	label?: string;
 	codec?: string;
 	isDefault?: boolean;
+	channels?: number;
 }
 export type IAudioTrack = IBaseTrack;
 interface ITextTrackBase {

package/types/providers/DashProvider/baseDashProvider.d.ts

@@ -6,7 +6,7 @@ import type { IProvider, IProviderParams } from "../types";
 import type { IObservableVideo } from "../utils/HTMLVideoElement/observable";
 import { TrackHistory } from "../../utils/autoSelectTrack";
 import type { IStateMachine } from "../../utils/StateMachine/types";
-import type { ISubscription, ITracer, Milliseconds, Nullable } from "@vkontakte/videoplayer-shared";
+import type { ExactVideoQuality, ISubscription, ITracer, Milliseconds, Nullable } from "@vkontakte/videoplayer-shared";
 import { Player } from "./lib/player";
 import { Scene3D } from "../../utils/3d/Scene3D";
 import DroppedFramesManager from "../utils/HTMLVideoElement/DroppedFramesManager";
@@ -19,6 +19,7 @@ type IParams = IProviderParams<IDashURLSource> & {
 	forceVideoCodec?: VideoCodec;
 	failedVideoTrack?: Nullable<IVideoTrack>;
 	isOnDemand?: boolean;
+	dashMaxTvVideoQuality?: Nullable<ExactVideoQuality>;
 };
 export default abstract class BaseDashProvider implements IProvider {
 	scene3D: Scene3D | undefined;
@@ -30,7 +31,7 @@ export default abstract class BaseDashProvider implements IProvider {
 	protected player: Player;
 	protected params: IParams;
 	protected tracer: ITracer;
-	protected textTracksManager: TextTrackManager;
+	protected textTracksManager: TextTrackManager | null;
 	protected droppedFramesManager: DroppedFramesManager;
 	protected stallsManager: StallsManager;
 	protected elementSizeManager: ElementSizeManager;

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

@@ -3,6 +3,7 @@ import type { IError, IRange, ISubject, IValueSubject, Milliseconds } from "@vko
 import { abortable } from "@vkontakte/videoplayer-shared";
 import type { Fetcher } from "./fetcher";
 import type { CommonInit, Manifest, Representation, Segment, Stream, StreamKind } from "../../utils/parsers/types";
+import type { VideoSegmentLoadProgress } from "../../utils/Abr/types";
 export interface Dependencies {
 	fetcher: Fetcher;
 	tuning: ITuningConfig;
@@ -75,7 +76,7 @@ export declare class BufferManager {
 	private loadByteRangeSegmentsTimeoutId;
 	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): void;
+	switchToWithPreviousAbort(newRepresentationId: Representation["id"], dropBuffer?: boolean): Promise<void | undefined>;
 	switchTo: ReturnType<typeof abortable<[Representation["id"], boolean | undefined], void>>;
 	switchToOld: ReturnType<typeof abortable<[Representation["id"], boolean | undefined], void>>;
 	warmUpMediaSource(): void;
@@ -125,6 +126,8 @@ export declare class BufferManager {
 	getDebugBufferState(): IRange<Milliseconds> | undefined;
 	getForwardBufferDuration(currentPosition?: Milliseconds | undefined): Milliseconds;
 	getForwardBufferRepresentations(currentPosition?: Milliseconds | undefined): Map<Representation["id"], Segment[]>;
+	getMpdSegmentDuration(): Milliseconds | undefined;
+	getActiveSegmentProgress(): VideoSegmentLoadProgress | undefined;
 	private detectGaps;
 	private detectGapsWhenIdle;
 	private checkEjectedSegments;

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

@@ -5,8 +5,9 @@ import { StreamKind } from "../../utils/parsers/types";
 import StateMachine from "../../../utils/StateMachine/StateMachine";
 import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
 import type { ITuningConfig } from "../../../utils/tuningConfig";
-import type { IError, ISubject, ITracer, IValueSubject, Milliseconds } from "@vkontakte/videoplayer-shared";
+import type { ExactVideoQuality, IError, ISubject, ITracer, IValueSubject, Milliseconds, Nullable } from "@vkontakte/videoplayer-shared";
 import { abortable, Subject } from "@vkontakte/videoplayer-shared";
+import type { VideoSegmentLoadProgress } from "../../utils/Abr/types";
 export declare enum State {
 	NONE = "none",
 	MANIFEST_READY = "manifest_ready",
@@ -20,6 +21,7 @@ export interface Params {
 	forceVideoCodec?: VideoCodec;
 	tracer: ITracer;
 	isOnDemand: boolean;
+	dashMaxTvVideoQuality: Nullable<ExactVideoQuality>;
 }
 export declare class Player {
 	private element;
@@ -84,6 +86,7 @@ export declare class Player {
 	private livePauseWatchdogSubscription;
 	private liveWasInterrupted;
 	private isOnDemand;
+	private dashMaxTvVideoQuality;
 	private destroyController;
 	constructor(params: Params);
 	initManifest: ReturnType<typeof abortable<[HTMLVideoElement, string, number]>>;
@@ -101,6 +104,8 @@ export declare class Player {
 	get isStreamEnded(): boolean;
 	stop(): void;
 	getForwardBufferRepresentations(kind: Exclude<StreamKind, StreamKind.TEXT>): Map<Representation["id"], Segment[]> | undefined;
+	getActiveVideoSegmentProgress(): VideoSegmentLoadProgress | undefined;
+	getMpdVideoSegmentDuration(): Milliseconds | undefined;
 	setBufferTarget(time: Milliseconds): void;
 	getStreams(): Manifest["streams"] | undefined;
 	getCodecs(): Manifest["codecs"] | undefined;

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

@@ -7,7 +7,7 @@ export declare const representationToTextTrack: ({ language, label }: Stream, {
 	isAuto: boolean;
 }) => IInternalTextTrack;
 export declare const textRepresentationToTextTrack: ({ language, label, id, url, isAuto }: TextRepresentation) => IInternalTextTrack;
-export declare const streamToIAudioStream: ({ id, language, label, codecs, isDefault }: Stream) => IAudioStream;
+export declare const streamToIAudioStream: ({ id, language, label, codecs, isDefault, channels }: Stream) => IAudioStream;
 export declare const streamToIVideoStream: ({ id, language, label, hdr, codecs }: Stream) => IVideoStream;
 export declare const isTemplateSegment: (segment: Segment) => segment is TemplateSegment;
 export declare const isTemplateSegmentReference: (segmentReference: SegmentReference) => segmentReference is TemplateSegmentReference;

package/types/providers/DashProviderVirtual/baseDashProvider.d.ts

@@ -6,7 +6,7 @@ import type { IProvider, IProviderParams } from "../types";
 import type { IObservableVideo } from "../utils/HTMLVideoElement/observable";
 import { TrackHistory } from "../../utils/autoSelectTrack";
 import type { IStateMachine } from "../../utils/StateMachine/types";
-import type { ISubscription, ITracer, Milliseconds, Nullable } from "@vkontakte/videoplayer-shared";
+import type { ExactVideoQuality, ISubscription, ITracer, Milliseconds, Nullable } from "@vkontakte/videoplayer-shared";
 import { Scene3D } from "../../utils/3d/Scene3D";
 import DroppedFramesManager from "../utils/HTMLVideoElement/DroppedFramesManager";
 import TextTrackManager from "../utils/HTMLVideoElement/TextTrackManager";
@@ -19,6 +19,7 @@ type IParams = IProviderParams<IDashURLSource> & {
 	forceVideoCodec?: VideoCodec;
 	failedVideoTrack?: Nullable<IVideoTrack>;
 	isOnDemand?: boolean;
+	dashMaxTvVideoQuality?: Nullable<ExactVideoQuality>;
 };
 export default abstract class BaseDashProvider implements IProvider {
 	scene3D: Scene3D | undefined;
@@ -30,7 +31,7 @@ export default abstract class BaseDashProvider implements IProvider {
 	protected player: BasePlayer;
 	protected params: IParams;
 	protected tracer: ITracer;
-	protected textTracksManager: TextTrackManager;
+	protected textTracksManager: TextTrackManager | null;
 	protected droppedFramesManager: DroppedFramesManager;
 	protected stallsManager: StallsManager;
 	protected elementSizeManager: ElementSizeManager;

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

@@ -2,6 +2,7 @@ import type { Byte, IError, IRange, ISubject, IValueSubject, Milliseconds } from
 import type { CommonInit, Manifest, Representation, Segment } from "../../../utils/parsers/types";
 import type { Fetcher } from "../fetcher";
 import type { ITuningConfig } from "../../../../utils/tuningConfig";
+import type { VideoSegmentLoadProgress } from "../../../utils/Abr/types";
 export type TRepresentationSwitchMode = "lazy" | "force";
 export declare enum SwithRepresentationMode {
 	Lazy = "lazy",
@@ -37,6 +38,8 @@ export interface IVirtualBufferManager<T extends Segment = Segment> {
 	setPreloadOnly(preloadOnly: boolean): void;
 	findSegmentStartTime(position: Milliseconds): Milliseconds | undefined;
 	calculateDurationFromSegments(): Milliseconds;
+	getActiveSegmentProgress(): VideoSegmentLoadProgress | undefined;
+	getMpdSegmentDuration(): Milliseconds | undefined;
 	destroy(): void;
 	get lastDataObtainedTimestamp(): Milliseconds;
 }
@@ -44,6 +47,7 @@ export interface IBufferPlaybackQueueItem<T extends Segment> {
 	representationId: Representation["id"];
 	segmentIndex: number;
 	segment: T;
+	startedAtMs?: Milliseconds;
 }
 export interface ISomeDataLoadedCallbackParams<T extends Segment> {
 	downloadingItems: IBufferPlaybackQueueItem<T>[];

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

@@ -6,6 +6,7 @@ import type { Byte, IError, IRange, ISubject, IValueSubject, Milliseconds, Secon
 import { abortable, Subscription } from "@vkontakte/videoplayer-shared";
 import type { NativeBufferManager } from "../nativeBufferManager";
 import { SwithRepresentationMode, type Dependencies, type IBufferPlaybackQueueItem, type ISomeDataLoadedCallbackParams, type IVirtualBufferManager } from "../types";
+import type { VideoSegmentLoadProgress } from "../../../../utils/Abr/types";
 export declare abstract class BaseVirtualBufferManager<T extends Segment> implements IVirtualBufferManager<T> {
 	error$: ISubject<IError>;
 	playingRepresentation$: IValueSubject<Representation["id"] | undefined>;
@@ -70,6 +71,8 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	getRepresentationInitialTime(): Seconds;
 	getMutexInfo(): string;
 	calculateDurationFromSegments(): Milliseconds;
+	getActiveSegmentProgress(): VideoSegmentLoadProgress | undefined;
+	getMpdSegmentDuration(): Milliseconds | undefined;
 	get lastDataObtainedTimestamp(): Milliseconds;
 	setTarget(time: Milliseconds): void;
 	setPreloadOnly(preloadOnly: boolean): void;

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

@@ -7,6 +7,7 @@ import type ThroughputEstimator from "../../../../utils/ThroughputEstimator";
 import type { ITuningConfig } from "../../../../utils/tuningConfig";
 import type { IError, IRange, ISubject, ISubscription, ITracer, IValueSubject, Milliseconds, Nullable, Seconds } from "@vkontakte/videoplayer-shared";
 import { abortable, Subject, Subscription, SubscriptionRemovable } from "@vkontakte/videoplayer-shared";
+import type { VideoSegmentLoadProgress } from "../../../utils/Abr/types";
 import { Fetcher } from "../fetcher";
 import type { Dependencies, IVirtualBufferManager, SwithRepresentationMode } from "../buffer/types";
 import type { Params } from "./types";
@@ -72,6 +73,7 @@ export declare abstract class BasePlayer {
 	fetcherError$: Subject<IError>;
 	updateDurationError$: Subject<IError>;
 	private isOnDemand;
+	private dashMaxTvVideoQuality;
 	protected constructor(params: Params);
 	protected abstract prepareManifestUrlString(manifestBaseUrlString: string, offset: number): string;
 	protected abstract setSourceInitDuration(): void;
@@ -83,6 +85,8 @@ export declare abstract class BasePlayer {
 	seek(requestedPosition: Milliseconds, forcePrecise?: boolean): Promise<void>;
 	warmUpMediaSourceIfNeeded(position?: Milliseconds | undefined): void;
 	getForwardBufferRepresentations(kind: Exclude<StreamKind, StreamKind.TEXT>): Map<Representation["id"], Segment[]> | undefined;
+	getActiveVideoSegmentProgress(): VideoSegmentLoadProgress | undefined;
+	getMpdVideoSegmentDuration(): Milliseconds | undefined;
 	get isStreamEnded(): boolean;
 	getStreams(): Manifest["streams"] | undefined;
 	getCodecs(): Manifest["codecs"] | undefined;

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

@@ -1,7 +1,7 @@
 import type ThroughputEstimator from "../../../../utils/ThroughputEstimator";
 import type { ITuningConfig } from "../../../../utils/tuningConfig";
 import type { VideoCodec } from "../../../../player/types";
-import type { ITracer } from "@vkontakte/videoplayer-shared";
+import type { ExactVideoQuality, ITracer, Nullable } from "@vkontakte/videoplayer-shared";
 export declare enum State {
 	NONE = "none",
 	MANIFEST_READY = "manifest_ready",
@@ -15,4 +15,5 @@ export interface Params {
 	forceVideoCodec?: VideoCodec;
 	tracer: ITracer;
 	isOnDemand?: boolean;
+	dashMaxTvVideoQuality?: Nullable<ExactVideoQuality>;
 }

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

@@ -1,13 +1,13 @@
 import type { Representation, Segment, SegmentReference, Stream, TemplateSegment, TemplateSegmentReference, TextRepresentation } from "../../utils/parsers/types";
 import type { IAudioStream, IAudioTrack, IInternalTextTrack, IVideoStream, IVideoTrack } from "../../../player/types";
-export declare const representationToVideoTrack: ({ id, width, height, bitrate, fps, quality: qualityString, streamId }: Representation) => IVideoTrack | undefined;
+export declare const representationToVideoTrack: ({ id, width, height, bitrate, fps, quality: qualityString, streamId, tvDisabled }: Representation) => IVideoTrack | undefined;
 export declare const representationToAudioTrack: ({ id, bitrate }: Representation) => IAudioTrack;
 export declare const representationToTextTrack: ({ language, label }: Stream, { id, url, isAuto }: Representation & {
 	url: string;
 	isAuto: boolean;
 }) => IInternalTextTrack;
 export declare const textRepresentationToTextTrack: ({ language, label, id, url, isAuto }: TextRepresentation) => IInternalTextTrack;
-export declare const streamToIAudioStream: ({ id, language, label, codecs, isDefault }: Stream) => IAudioStream;
+export declare const streamToIAudioStream: ({ id, language, label, codecs, isDefault, channels }: Stream) => IAudioStream;
 export declare const streamToIVideoStream: ({ id, language, label, hdr, codecs }: Stream) => IVideoStream;
 export declare const isTemplateSegment: (segment: Segment) => segment is TemplateSegment;
 export declare const isTemplateSegmentReference: (segmentReference: SegmentReference) => segmentReference is TemplateSegmentReference;

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

@@ -15,6 +15,7 @@ interface IParams extends IProviderDependencies {
 	volumeMultiplier?: number;
 	panelSize?: IRectangle;
 	skipVideoElVolumeSync$: ValueSubject<boolean>;
+	handleNetworkRecoverableErrorAsProviderError?: boolean;
 }
 export default class ProviderContainer implements IProviderContainer {
 	current$: IValueSubject<IProviderEntry>;
@@ -36,6 +37,7 @@ export default class ProviderContainer implements IProviderContainer {
 	private failoverIndex;
 	private currentFailedVideoTrack;
 	private volumeMultiplierManager;
+	private dashMaxTvVideoQuality;
 	constructor(params: IParams);
 	init(): void;
 	destroy(): void;

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

@@ -1,4 +1,5 @@
-import { VideoFormat, VideoCodec, AudioCodec } from "../../../player/types";
+import type { VideoCodec } from "../../../player/types";
+import { VideoFormat, VideoCodecName, AudioCodec } from "../../../player/types";
 import { type ITuningConfig } from "../../../utils/tuningConfig";
 type VodFormat = VideoFormat.MPEG | VideoFormat.DASH_SEP | VideoFormat.DASH_WEBM | VideoFormat.DASH_WEBM_AV1 | VideoFormat.DASH_STREAMS | VideoFormat.DASH_ONDEMAND | VideoFormat.HLS | VideoFormat.HLS_FMP4 | VideoFormat.HLS_ONDEMAND;
 type Constraints = Pick<ITuningConfig, "webmCodec" | "androidPreferredFormat" | "iosPreferredFormat" | "preferCMAF" | "preferWebRTC" | "preferMultiStream">;
@@ -15,7 +16,13 @@ type AllLiveFormats = [LiveFormat, LiveFormat, LiveFormat, LiveFormat, LiveForma
 export declare const getLiveFormatsPriority: ({ androidPreferredFormat, preferCMAF, preferWebRTC }: Constraints) => AllLiveFormats;
 export declare const getChromeCastFormatsPriority: (live: boolean) => VideoFormat[];
 export declare const selectCodec: (codecs: Set<string>) => string | undefined;
-export declare const filterAvailableVideoCodecs: (codecs: string[]) => VideoCodec[];
+type CodecStream = {
+	codecs: string;
+	hdr?: boolean;
+};
+export declare const filterAvailableVideoCodecs: (streams: CodecStream[], { preferHdr }: {
+	preferHdr: boolean;
+}) => VideoCodec[];
 export declare const filterAvailableAudioCodecs: (codecs: string[]) => AudioCodec[];
-export declare const convertCodecName: <T extends VideoCodec | AudioCodec>(codec: string) => T;
+export declare const convertCodecName: <T extends VideoCodecName | AudioCodec>(codec: string) => T;
 export {};

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

@@ -1,4 +1,4 @@
-import type { IAbrController, IAbrRule, IBaseAbrControllerContext, IInitAbrManagerContext } from "./types";
+import type { IAbrController, IAbrRule, IBaseAbrControllerContext, IRuleInitContext } from "./types";
 import type { IBaseTrack } from "../../../player/types";
 export default class AbrController<
 	T extends IBaseTrack,
@@ -6,10 +6,13 @@ export default class AbrController<
 > implements IAbrController<T> {
 	private history;
 	private rules;
-	private context;
-	init(rules: IAbrRule<T, C>[], initContext: IInitAbrManagerContext): void;
+	private _context;
+	get context(): C;
+	init(rules: IAbrRule<T, C>[], initContext: IRuleInitContext): void;
 	destroy(): void;
 	updateContext(context: C): void;
-	autoSelectTrack(): T;
+	autoSelectTrack(rules?: IAbrRule<T, C>[]): T;
 	private selectTrackBasedOnHistory;
+	/** при переключении аудио стрима очищаем историю для предотвращения залипания в `onCooldown` */
+	historyReset(): void;
 }

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

@@ -8,6 +8,8 @@ export declare class AbrManager {
 	private subscription;
 	private lastVideoTrackSelected$;
 	private context;
+	private phaseController;
+	private allVideoRules;
 	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/abrPhaseController.d.ts

@@ -0,0 +1,17 @@
+import type { IObservable } from "@vkontakte/videoplayer-shared";
+import type { IVideoAbrContext, RuleConfidence } from "../types";
+export declare enum AbrPhase {
+	Startup = "startup",
+	Steady = "steady"
+}
+export type RulePhaseConfig = Readonly<Partial<Record<AbrPhase, RuleConfidence>>>;
+export declare const uniformPhaseConfig: (confidence: RuleConfidence) => RulePhaseConfig;
+export declare class AbrPhaseController {
+	private _phase;
+	private readonly subscription;
+	constructor(isSeeked$?: IObservable<boolean>);
+	get phase(): AbrPhase;
+	updatePhase(context: IVideoAbrContext): void;
+	reset(): void;
+	destroy(): void;
+}

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

@@ -1,11 +1,12 @@
-import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext } from "../../types";
 import type { IAudioTrack, IVideoTrack } from "../../../../../player/types";
 import { LimitAboveRule } from "../limitAboveRule";
 import type { Kbps, Nullable } from "@vkontakte/videoplayer-shared";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type AudioThroughputLogsArgs = [forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig];
 export declare class AudioThroughputRule extends LimitAboveRule<IAudioTrack, IAudioAbrContext, AudioThroughputLogsArgs> implements IAbrRule<IAudioTrack, IAudioAbrContext> {
-	constructor(confidence: RuleConfidence);
+	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;
 }

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

@@ -1,11 +1,12 @@
-import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext } from "../../types";
 import type { IAudioTrack, IVideoTrack } from "../../../../../player/types";
 import { LimitBelowRule } from "../limitBelowRule";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
 import type { Nullable } from "@vkontakte/videoplayer-shared";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type MinAudioForVideoLogsArgs = [lastVideoTrackSelected: Nullable<IVideoTrack>, tuning: ITuningConfig];
 export declare class MinAudioForVideoRule extends LimitBelowRule<IAudioTrack, IAudioAbrContext, MinAudioForVideoLogsArgs> implements IAbrRule<IAudioTrack, IAudioAbrContext> {
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IAudioAbrContext): IAbrRuleResolution<IAudioTrack>;
 	protected createLogMessage(selectedTrack: IVideoTrack, lastVideoTrackSelected: Nullable<IVideoTrack>, tuning: ITuningConfig): string;
 }

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

@@ -1,7 +1,7 @@
 import { AudioRuleName } from "../types";
 import type { IAbrRule, IAudioAbrContext } from "../types";
-import { RuleConfidence } from "../types";
 import type { IAudioTrack } from "../../../../player/types";
+import { type RulePhaseConfig } from "../controllers/abrPhaseController";
 export declare class AudioRuleFactory {
-	static createRule(ruleName: AudioRuleName, confidence?: RuleConfidence): IAbrRule<IAudioTrack, IAudioAbrContext>;
+	static createRule(ruleName: AudioRuleName, phaseConfig?: RulePhaseConfig): IAbrRule<IAudioTrack, IAudioAbrContext>;
 }

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

@@ -1,19 +1,23 @@
-import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, IInitAbrManagerContext, RuleConfidence, RuleType } from "../types";
+import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, IRuleInitContext, RuleConfidence, RuleType } from "../types";
 import type { IBaseTrack } from "../../../../player/types";
 import { Subscription } from "@vkontakte/videoplayer-shared";
+import type { AbrPhase } from "../controllers/abrPhaseController";
+import { type RulePhaseConfig } from "../controllers/abrPhaseController";
 export declare abstract class BaseRule<
 	T extends IBaseTrack,
 	C extends IBaseAbrControllerContext,
 	LogsArgs extends unknown[]
 > implements IAbrRule<T, C> {
+	readonly phaseConfig: RulePhaseConfig;
+	readonly activePhases: ReadonlySet<AbrPhase>;
 	protected subscription: Subscription;
-	protected confidence: RuleConfidence;
 	protected type: RuleType;
 	protected name: string;
-	constructor(confidence: RuleConfidence);
-	init(_initContext: IInitAbrManagerContext): void;
+	protected confidence: RuleConfidence;
+	constructor(phaseConfig: RulePhaseConfig);
+	init(_initContext: IRuleInitContext): void;
 	destroy(): void;
 	abstract execute(context: C): IAbrRuleResolution<T>;
-	protected createResolution(selectedTrack: T, ...params: LogsArgs): IAbrRuleResolution<T>;
+	protected createResolution(context: C, selectedTrack: T, ...params: LogsArgs): IAbrRuleResolution<T>;
 	protected abstract createLogMessage(selectedTrack: T, ...params: LogsArgs): string;
 }

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

@@ -1,11 +1,12 @@
-import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, RuleConfidence } from "../types";
+import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext } from "../types";
 import type { IBaseTrack } from "../../../../player/types";
 import { BaseRule } from "./baseRule";
+import type { RulePhaseConfig } from "../controllers/abrPhaseController";
 export declare abstract class LimitAboveRule<
 	T extends IBaseTrack,
 	C extends IBaseAbrControllerContext,
 	LogsArgs extends unknown[] = unknown[]
 > extends BaseRule<T, C, LogsArgs> implements IAbrRule<T, C> {
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	abstract execute(context: C): IAbrRuleResolution<T>;
 }

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

@@ -1,11 +1,12 @@
-import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, RuleConfidence } from "../types";
+import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext } from "../types";
 import type { IBaseTrack } from "../../../../player/types";
 import { BaseRule } from "./baseRule";
+import type { RulePhaseConfig } from "../controllers/abrPhaseController";
 export declare abstract class LimitBelowRule<
 	T extends IBaseTrack,
 	C extends IBaseAbrControllerContext,
 	LogsArgs extends unknown[] = unknown[]
 > extends BaseRule<T, C, LogsArgs> implements IAbrRule<T, C> {
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	abstract execute(context: C): IAbrRuleResolution<T>;
 }

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

@@ -0,0 +1,12 @@
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { Milliseconds } from "@vkontakte/videoplayer-shared";
+import { LimitAboveRule } from "../limitAboveRule";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
+type LogsArgs = [elapsedMs: Milliseconds, loadedFraction: number, estimatedRemainingMs: Milliseconds, bufferLimitMs: Milliseconds, triggered: boolean];
+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;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, IVideoAbrContext } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { Kbps, Seconds } from "@vkontakte/videoplayer-shared";
+import { LimitAboveRule } from "../limitAboveRule";
+import { AbrPhase, type RulePhaseConfig } from "../../controllers/abrPhaseController";
+export declare const calculateUtilities: (bitratesAsc: Kbps[]) => number[];
+export declare const calculateVpAndGp: (utilityHigh: number, bufferTargetS: Seconds, minBufferS: Seconds) => {
+	Vp: number;
+	gp: number;
+};
+export declare const calculateScores: (bitratesAsc: Kbps[], utilities: number[], Vp: number, gp: number, effectiveBufferS: Seconds) => number[];
+export declare const argmax: (values: number[]) => number;
+export declare const adjustBufferForFinite: (effectiveBufferS: Seconds, remainingDurationS: Seconds, finiteThresholdS: Seconds, _bufferTargetS: Seconds) => Seconds;
+export declare const calculateMinBufferLevelForRep: (qIndex: number, bitratesAsc: Kbps[], utilities: number[], Vp: number, gp: number) => Seconds;
+export declare const calculateMaxBufferLevelForRep: (qIndex: number, utilities: number[], Vp: number, gp: number) => Seconds;
+export declare const pickIndexByThroughput: (bitratesAsc: Kbps[], throughputKbps: Kbps) => number;
+type BolaLogsArgs = [bufferLevelS: Seconds, placeholderBufferS: Seconds, segmentDurationS: Seconds, Vp: number, gp: number, validBitrates: Kbps[], selectedIndex: number, phase: AbrPhase | undefined];
+export declare class BolaRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, BolaLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	private placeholderBufferS;
+	private lastCallTimeMs;
+	private lastBufferLevelS;
+	constructor(phaseConfig: RulePhaseConfig);
+	init(initContext?: IRuleInitContext): void;
+	destroy(): void;
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	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;
+}
+export {};

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

@@ -1,11 +1,16 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Nullable } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type BufferRuleLogsArgs = [currentVideoTrack: Nullable<IVideoTrack>, lastVideoTrackSelected: Nullable<IVideoTrack>, forwardBufferHealth: Nullable<number>, abrTuning: ITuningConfig["autoTrackSelection"]];
+/**
+* @deprecated Заменено на связку `BolaRule` + `InsufficientBufferRule` в фазовой архитектуре ABR.
+* Не использовать в новых наборах правил.
+*/
 export declare class BufferRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, BufferRuleLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
-	constructor(confidence: RuleConfidence);
+	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;
 }

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

@@ -1,12 +1,13 @@
-import type { IAbrRule, IAbrRuleResolution, IInitAbrManagerContext, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, IVideoAbrContext } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Nullable } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type FailedVideoTracLogsArgs = [banTrack: Nullable<IVideoTrack>];
 export declare class FailedVideoTrackRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, FailedVideoTracLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
 	protected banTrack: Nullable<IVideoTrack>;
-	constructor(confidence: RuleConfidence);
-	init(initContext: IInitAbrManagerContext): void;
+	constructor(phaseConfig: RulePhaseConfig);
+	init(initContext: IRuleInitContext): void;
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
 	protected createLogMessage(selectedTrack: IVideoTrack, banTrack: Nullable<IVideoTrack>): string;
 }

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

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