@vkontakte/videoplayer-core 2.0.161-dev.eddfe39b7.0 → 2.0.162-dev.3fab5a629.0

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;

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

@@ -0,0 +1,15 @@
+import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, 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 = [forwardBufferDuration: Milliseconds | undefined, thresholdMs: Milliseconds, triggered: boolean, suppressedByGrace: boolean];
+export declare class InsufficientBufferRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, LogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	private lastPlaybackResetAtMs;
+	constructor(phaseConfig: RulePhaseConfig);
+	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;
+}
+export {};

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

@@ -1,11 +1,12 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Nullable, QualityLimits } from "@vkontakte/videoplayer-shared";
 import { type ExactVideoQuality } from "@vkontakte/videoplayer-shared";
 import { LimitBelowRule } from "../limitBelowRule";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type LowerLimitLogsArgs = [limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, limits: QualityLimits];
 export declare class LowerLimitRule extends LimitBelowRule<IVideoTrack, IVideoAbrContext, LowerLimitLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
 	protected createLogMessage(selectedTrack: IVideoTrack, limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, limits: QualityLimits): string;
 }

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

@@ -1,8 +1,9 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Kbps, Nullable } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type StallLogsArgs = [forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, tuning: ITuningConfig];
 export declare class StallsRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, StallLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
 	private severeStallOccurred;
@@ -10,7 +11,7 @@ export declare class StallsRule extends LimitAboveRule<IVideoTrack, IVideoAbrCon
 	private lastStallDurationRestriction;
 	private maxQualityLimitOnStall;
 	private predictedThroughputWithoutData;
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
 	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, tuning: ITuningConfig): string;
 	private updateStallQualityLimits;

package/types/providers/utils/Abr/rules/video/throughputRule.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 { Kbps, Nullable } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
-type ThroughputLogsArgs = [forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig];
+import { AbrPhase, type RulePhaseConfig } from "../../controllers/abrPhaseController";
+type ThroughputLogsArgs = [forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, phase: AbrPhase | undefined, tuning: ITuningConfig];
 export declare class ThroughputRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, ThroughputLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
-	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig): string;
+	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, phase: AbrPhase | undefined, tuning: ITuningConfig): string;
 }
 export {};

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

@@ -1,12 +1,70 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Nullable, QualityLimits, VideoQuality } from "@vkontakte/videoplayer-shared";
 import { type ExactVideoQuality } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
-type UpperLimitsLogsArgs = [limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality];
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
+type UpperLimitsLogsArgs = [limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality, effectiveType: string | undefined, connectionDataQualityLimit: ExactVideoQuality | undefined];
+/**
+* Правило верхнего ограничения качества в авто-ABR. Из списка `videoTracksDesc`
+* (отсортирован от высшего к низшему) выбирает самый высокий трек, который
+* одновременно удовлетворяет ВСЕМ активным лимитам сверху. Если подходящего
+* нет — возвращает минимально доступный трек (graceful fallback).
+*
+* Источники лимитов сверху (действуют совместно, победитель — самый строгий):
+*
+* 1. `context.limits.max` — явный пользовательский/интеграционный лимит.
+*    Приходит из публичного API `Player.setAutoQualityLimits({ max, min })`
+*    (см. `packages/core/src/player/Player.ts`). Слой UI/интеграция пробрасывает
+*    его в `desiredState.autoVideoTrackLimits` → `AbrManager.updateContext({ limits })`
+*    → `IVideoAbrContext.limits`. `undefined` в `limits` или `limits.max` снимает
+*    лимит. Значение типа `ExactVideoQuality` (например, '720p'), трактуется
+*    включительно (`<=`). Если лимиты невалидны (min > max, либо min выше
+*    highestAvailable, либо max ниже lowestAvailable) — см. `areLimitsInvalid` —
+*    лимит игнорируется целиком, чтобы не заблокировать воспроизведение.
+*
+*    Реальные кейсы:
+*    - Пользователь в настройках плеера выбрал пресет «Экономия трафика»
+*      (`PredefinedQualityLimits.TRAFFIC_SAVING`) — хост передаёт
+*      `{ max: tuning.autoTrackSelection.trafficSavingLimit }` (Q_480P).
+*    - Хост-приложение (мини-апп ВК, лента) ограничивает качество для
+*      превью/фонового воспроизведения.
+*    - A/B-эксперимент или бизнес-правило режет качество для конкретной
+*      категории видео / региона / тарифа.
+*
+* 2. `tuning.autoTrackSelection.backgroundVideoQualityLimit` — применяется
+*    только когда `context.visible === false` (плеер вне viewport, по данным
+*    `elementVisible$` из `observeElementVisibility`, порог — `activeVideoAreaThreshold`).
+*
+*    Реальные кейсы: автовоспроизведение в ленте при прокрутке мимо плеера,
+*    PiP/мини-плеер в фоне, неактивная вкладка.
+*
+* 3. `effectiveType` из Network Information API (`navigator.connection`).
+*    Активируется `tuning.dash.useConnectionDataUpperLimit`.
+*    Приоритет разрешения в `connectionDataQualityLimit`:
+*      a. `effectiveType ∈ {'2g', 'slow-2g'}` → `tuning.dash.saveData2gQualityLimit`
+*         (Q_360P) — жёсткий лимит на очень слабой сети.
+*      b. `effectiveType === '3g'` → `tuning.dash.saveData3gQualityLimit` (Q_480P).
+*      c. Иначе — без ограничения.
+*
+*    Network Information API доступен только в Chromium (Android, десктоп Chrome/Edge/
+*    Opera/Samsung Internet, Android WebView). В Firefox, Safari и Chrome iOS
+*    (WebKit) `navigator.connection === undefined` — этот источник лимита
+*    неактивен, правило работает только по п.1 и п.2.
+*
+*    Реальные кейсы: пользователь в метро / зоне слабого сигнала, пользователь
+*    на edge/3G-тарифе.
+*
+* Все три источника комбинируются операцией AND: трек проходит, если
+* `fitsLimits && fitsBackgroundVideoQualityLimit && fitsSaveDataLimit`. Поэтому
+* итоговый потолок = минимум из активных. Нижнюю границу закрывает
+* `LowerLimitRule` (поле `limits.min` здесь не используется).
+*/
 export declare class UpperLimitsRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, UpperLimitsLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
-	protected createLogMessage(selectedTrack: IVideoTrack, limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality): string;
+	protected createLogMessage(selectedTrack: IVideoTrack, limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality, effectiveType: string | undefined, connectionDataQualityLimit: ExactVideoQuality | undefined): string;
+	private getConnection;
+	private resolveConnectionDataQualityLimit;
 }
 export {};

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

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

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

@@ -1,22 +1,27 @@
 import type { IAudioTrack, IBaseTrack, IVideoTrack } from "../../../player/types";
-import type { IComponentLogger, IObservable, IRectangle, IValueSubject, Kbps, Milliseconds, Nullable, QualityLimits } from "@vkontakte/videoplayer-shared";
+import type { Byte, IComponentLogger, IObservable, IRectangle, IValueSubject, Kbps, Milliseconds, Nullable, QualityLimits } from "@vkontakte/videoplayer-shared";
 import type { ITuningConfig } from "../../../utils/tuningConfig";
 import type { Representation, Segment } from "../parsers/types";
 import type { ElementSizeManager } from "../HTMLVideoElement/ElementSizeManager";
 import type { IObservableVideo } from "../HTMLVideoElement/observable";
+import type { AbrPhase } from "./controllers/abrPhaseController";
 export declare enum RuleConfidence {
 	Low = 0,
 	Normal = 1,
 	High = 2
 }
 export declare enum VideoRuleName {
+	/** @deprecated Заменено на `Bola` + `InsufficientBuffer` в фазовой архитектуре ABR. */
 	Buffer = "buffer_rule",
+	Bola = "bola_rule",
 	FitsContainer = "fits_container_rule",
 	FailedVideoTrack = "failed_video_track_rule",
 	Stalls = "stalls_rule",
 	LowerLimit = "lower_limit_rule",
 	UpperLimit = "upper_limit_rule",
-	Throughput = "throughput_rule"
+	Throughput = "throughput_rule",
+	AbandonRequest = "abandon_request_rule",
+	InsufficientBuffer = "insufficient_buffer_rule"
 }
 export declare enum AudioRuleName {
 	MinAudioForVideo = "min_audio_for_video_rule",
@@ -36,6 +41,11 @@ export interface IUpdatableAbrManagerContext {
 	forwardBufferHealth?: number;
 	forwardVideoBufferRepresentations: Nullable<Map<Representation["id"], Segment[]>>;
 	forwardAudioBufferRepresentations: Nullable<Map<Representation["id"], Segment[]>>;
+	forwardBufferDuration?: Milliseconds;
+	videoSegmentLoadProgress?: VideoSegmentLoadProgress;
+	isLive?: boolean;
+	remainingDurationMs?: Milliseconds;
+	mpdSegmentDurationMs?: Milliseconds;
 }
 export interface IInitAbrManagerContext {
 	tuning: ITuningConfig;
@@ -44,6 +54,7 @@ export interface IInitAbrManagerContext {
 	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds>;
 	throughput$: IValueSubject<Kbps>;
 	rtt$: IValueSubject<Milliseconds>;
+	throughputVariance$?: IValueSubject<number>;
 	element: HTMLVideoElement;
 	failedVideoTrack: Nullable<IVideoTrack>;
 	abrLogger: IComponentLogger;
@@ -70,19 +81,21 @@ export interface IAbrRuleResolution<T extends IBaseTrack> {
 	name: string;
 	logMessage: string;
 }
+export interface IRuleInitContext extends IInitAbrManagerContext {}
 export interface IAbrRule<
 	T extends IBaseTrack,
 	C extends IBaseAbrControllerContext
 > {
-	init(initContext: IInitAbrManagerContext): void;
+	readonly activePhases: ReadonlySet<AbrPhase>;
+	init(initContext: IRuleInitContext): void;
 	destroy(): void;
 	execute(context: C): IAbrRuleResolution<T>;
 }
 export interface IAbrController<T extends IBaseTrack> {
-	init(rules: IAbrRule<T, IBaseAbrControllerContext>[], initContext: IInitAbrManagerContext): void;
+	init(rules: IAbrRule<T, IBaseAbrControllerContext>[], initContext: IRuleInitContext): void;
 	destroy(): void;
 	updateContext(context: IBaseAbrControllerContext): void;
-	autoSelectTrack(): T;
+	autoSelectTrack(rules?: IAbrRule<T, IBaseAbrControllerContext>[]): T;
 }
 export interface IBaseAbrControllerContext extends IVideoTracksContext {
 	currentVideoTrack: Nullable<IVideoTrack>;
@@ -92,8 +105,16 @@ export interface IBaseAbrControllerContext extends IVideoTracksContext {
 	estimatedThroughput: Kbps;
 	reserve: Kbps;
 	forwardBufferHealth: Nullable<number>;
+	forwardBufferDuration: Milliseconds | undefined;
 	playbackRate: number;
+	throughputVariance: number;
 }
+export type VideoSegmentLoadProgress = {
+	startedAtMs: Milliseconds;
+	loadedBytes: Byte;
+	totalBytes: Byte | undefined;
+	segmentDurationMs: Milliseconds;
+};
 export interface IVideoAbrContext extends IBaseAbrControllerContext {
 	container: Nullable<IRectangle>;
 	panelSize: Nullable<IRectangle>;
@@ -102,6 +123,11 @@ export interface IVideoAbrContext extends IBaseAbrControllerContext {
 	visible: boolean;
 	severeStallOccurred: boolean;
 	lastStallDuration: Milliseconds;
+	videoSegmentLoadProgress?: VideoSegmentLoadProgress;
+	remainingDurationMs: Milliseconds | undefined;
+	isLive: boolean;
+	mpdSegmentDurationMs: Milliseconds | undefined;
+	phase?: AbrPhase;
 }
 export type IAudioAbrContext = IBaseAbrControllerContext & IAudioTracksContext;
 export declare const isAudioAbrContext: (context: IBaseAbrControllerContext) => context is IAudioAbrContext;

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

@@ -1,5 +1,6 @@
-import type { Nullable } from "@vkontakte/videoplayer-shared";
+import type { Milliseconds, Nullable } from "@vkontakte/videoplayer-shared";
 import type { IAudioTrack, IBaseTrack, IVideoTrack } from "../../../player/types";
+export declare const bufferToPlaybackMs: (contentMs: Milliseconds | undefined, playbackRate: number) => Milliseconds;
 export declare enum CompareTrack {
 	Descending = -1,
 	Ascending = 1

package/types/providers/utils/parsers/types.d.ts

@@ -116,6 +116,7 @@ export interface Stream {
 	label?: string;
 	codecs: string;
 	mime: string;
+	channels?: number;
 	representations: Representation[];
 }
 export interface Manifest {

package/types/utils/ThroughputEstimator.d.ts

@@ -20,6 +20,9 @@ declare class ThroughputEstimator {
 	addRawThroughput(rate: Kbps): void;
 	addRawRtt(time: Milliseconds): void;
 	private sanityCheck;
-	private static load;
+	get throughputVariance$(): IValueSubject<number>;
+	private static loadStored;
+	private static writeStored;
+	private static validateStored;
 }
 export default ThroughputEstimator;

package/types/utils/dashMaxTvVideoQuality.d.ts

@@ -0,0 +1,7 @@
+import { VideoFormat } from "../player/types";
+import type { Manifest } from "../providers/utils/parsers/types";
+import type { ExactVideoQuality, IError } from "@vkontakte/videoplayer-shared";
+import { VideoQuality } from "@vkontakte/videoplayer-shared";
+export declare const getDashMaxTvVideoQuality: (e: IError, videoFormat?: VideoFormat, currentQuality?: VideoQuality) => ExactVideoQuality | null;
+/** @mutates streams.video */
+export declare const markDashMaxTvVideoQuality: (streams: Manifest["streams"], dashMaxTvVideoQuality: ExactVideoQuality) => void;

package/types/utils/smoothedValue/baseSmoothedValue.d.ts

@@ -12,6 +12,7 @@ export declare abstract class BaseSmoothedValue implements ISmoothedValue {
 	protected params: IParams;
 	smoothed$: IValueSubject<number>;
 	debounced$: IValueSubject<number>;
+	varianceCoefficient$: IValueSubject<number>;
 	constructor(params: IParams);
 	protected abstract updateSmoothedValue(value: number): void;
 	next(value: number): void;

package/types/utils/smoothedValue/types.d.ts

@@ -22,5 +22,6 @@ export interface IEmaTopExtremumParams extends IParams {
 export interface ISmoothedValue {
 	smoothed$: IValueSubject<number>;
 	debounced$: IValueSubject<number>;
+	varianceCoefficient$: IValueSubject<number>;
 	next(value: number): void;
 }

package/types/utils/tuningConfig.d.ts

@@ -45,6 +45,24 @@ export type ITuningConfig = {
 			continuesByteSequenceInterval: Milliseconds;
 			maxLastEvaluationTimeout: Milliseconds;
 		};
+		/**
+		* TTL + проверка типа сети для кешированного throughput из localStorage.
+		* При включении: если сохранённое значение старше storedThroughputTtlMs
+		* или тип сети изменился (Wi-Fi→3G) — значение отбрасывается.
+		* Предотвращает старт в 4K при переходе с Wi-Fi на мобильную сеть.
+		*
+		* При OFF (дефолт): читаем/пишем как до фикса — plain number в legacy-ключ
+		* one_video_*. Это даёт безопасный rollback JS-версии без потери данных.
+		* При ON: новый формат (JSON с timestamp+networkType) → новый ключ vk_uvp_*.
+		*/
+		useThroughputTtl: boolean;
+		/**
+		* Срок жизни кешированного throughput (мс). По умолчанию 4 часа.
+		* После истечения TTL значение из localStorage игнорируется —
+		* используется browser estimation или initialThroughput.
+		* Применимо только при useThroughputTtl=true.
+		*/
+		storedThroughputTtlMs: Milliseconds;
 	};
 	autoTrackSelection: {
 		bitrateFactorAtEmptyBuffer: number;
@@ -130,6 +148,8 @@ export type ITuningConfig = {
 		useNewRepresentationSwitch: boolean;
 		useDelayedRepresentationSwitch: boolean;
 		useSmartRepresentationSwitch: boolean;
+		seekStallExitPolicy: boolean;
+		mutexStallExitPolicy: boolean;
 		useFetchPriorityHints: boolean;
 		useAbortMSEFix: boolean;
 		enableBaseUrlSupport: boolean;
@@ -154,14 +174,43 @@ export type ITuningConfig = {
 		useBufferHoldingOnlyOnStall: boolean;
 		useAbortResetNativeBufferMutex: boolean;
 		useNewAbr: boolean;
+		useAbrPhases: boolean;
 		abrVideoRules: VideoRuleName[];
 		abrAudioRules: AudioRuleName[];
 		useDynamicBirtateRule: boolean;
 		useNewFailoverLogic: boolean;
 		useFailoverHostsOnAllProviderCrash: boolean;
 		videoTrackBanAfterProviderFail: Milliseconds;
+		saveData3gQualityLimit: ExactVideoQuality;
+		saveData2gQualityLimit: ExactVideoQuality;
+		useConnectionDataUpperLimit: boolean;
+		abandon: {
+			minElapsedMs: Milliseconds;
+			bufferSafetyFactor: number;
+			minLoadedFraction: number;
+			minBufferToActivateMs: Milliseconds;
+		};
+		bola: {
+			bufferTargetMs: Milliseconds;
+			minBufferMs: Milliseconds;
+			minBufferPerBitrateLevelMs: Milliseconds;
+			placeholderBufferDecay: number;
+			fallbackSegmentDurationMs: Milliseconds;
+			finiteThresholdMs: Milliseconds;
+			adaptiveBufferTargetK: number;
+			adaptiveBufferTargetMaxMs: Milliseconds;
+			trimDetectThresholdMs: Milliseconds;
+			antiCascadeDownshift: boolean;
+		};
+		insufficientBuffer: {
+			thresholdMs: Milliseconds;
+			gracePeriodAfterPlaybackResetMs: Milliseconds;
+			budgetFactor: number;
+			fallbackSegmentDurationMs: Milliseconds;
+		};
 		videoStreamRepresentaionsFilter: [VideoQuality, number, VideoCodec][];
 		filterOnDemandQualityList: boolean;
+		dashMaxTvVideoQuality: boolean;
 	};
 	dashCmafLive: {
 		externalStopControl: boolean;
@@ -340,9 +389,19 @@ export type ITuningConfig = {
 	* Очищаем кэш урлов при падение провайдера.
 	*/
 	dropUrlCacheWhenProviderCrashed?: boolean;
+	/**
+	* При смене/реините провайдера игнорируем результат того, смогло видео заиграть или нет.
+	*/
+	ignoreForcePlayResultWhenProviderChanged?: boolean;
 	hls: {
 		filterOnDemandQualityList: boolean;
 	};
+	/** отключает субтитры в ядре */
+	disableSubtitles: boolean;
+	/**
+	* Устанавливаем длительность видео на основе последнего сегмента.
+	*/
+	useDurationFromSegments: boolean;
 };
 export type IOptionalTuningConfig = RecursivePartial<ITuningConfig>;
 export declare const fillDefault: (partial: IOptionalTuningConfig) => ITuningConfig;