@vkontakte/videoplayer-core 2.0.167 → 2.0.168-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.167",
+  "version": "2.0.168-beta.1",
   "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.96"
+    "@vkontakte/videoplayer-shared": "1.0.97-beta.1"
   }
 }

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

@@ -74,6 +74,7 @@ export declare class BufferManager {
 	private index;
 	private lastDataObtainedTimestampMs;
 	private loadByteRangeSegmentsTimeoutId;
+	private preDownloadedFirstSegment;
 	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>;
@@ -102,6 +103,7 @@ export declare class BufferManager {
 	private loadSegments;
 	private loadTemplateSegment;
 	private updateRepresentationsBaseUrlIfNeeded;
+	private feedPreDownloadedFirstSegment;
 	private loadByteRangeSegments;
 	private prepareByteRangeFetchSegmentParams;
 	private prepareTemplateFetchSegmentParams;

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

@@ -25,6 +25,8 @@ export interface IParams {
 	handleExtendedNetworkErrorsSet?: boolean;
 	useUrlCacheMechanism?: boolean;
 	measureNonSegmentRequests?: boolean;
+	measureFastSamples?: boolean;
+	preloadFirstSegment?: boolean;
 }
 export type Priority = "high" | "low" | "auto";
 export interface FetchParamsWithUrl extends FetchParams {
@@ -47,6 +49,7 @@ export type RepresentationFetchResult = {
 	init: CommonInit | null;
 	segments: Segment[];
 	dataView: DataView;
+	firstSegmentData?: ArrayBuffer;
 };
 export declare class Fetcher {
 	private throughputEstimator;
@@ -69,11 +72,13 @@ export declare class Fetcher {
 	private useEnableSubtitlesParam;
 	private useUrlCacheMechanism;
 	private measureNonSegmentRequests;
+	private measureFastSamples;
+	private preloadFirstSegment;
 	private startupPhase;
 	private performanceObserver;
 	private pendingConnectionMetrics;
 	private handleExtendedNetworkErrorsSet;
-	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, useUrlCacheMechanism, measureNonSegmentRequests }: IParams);
+	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, useUrlCacheMechanism, measureNonSegmentRequests, measureFastSamples, preloadFirstSegment }: IParams);
 	private onHeadersReceived;
 	private setupPerformanceObserver;
 	private processPerformanceResourceTiming;
@@ -87,6 +92,7 @@ export declare class Fetcher {
 	destroy(): void;
 	private fetchByteRangeRepresentation;
 	private fetchTemplateRepresentation;
+	private isLikelyCacheHitByTtfb;
 	private doFetch;
 	private unsubscribeAbortSubscription;
 }

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

@@ -0,0 +1,110 @@
+import type { Fetcher, FetchParamsWithUrl, Priority, RepresentationFetchResult } from "../../fetcher";
+import type { CommonInit, ContainerParser, Representation, Segment } from "../../../../utils/parsers/types";
+import { StreamKind } from "../../../../utils/parsers/types";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+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";
+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>;
+	playingRepresentationInit$: IValueSubject<CommonInit | undefined>;
+	currentSegmentLength$: IValueSubject<number>;
+	onLastSegment$: IValueSubject<boolean>;
+	fullyBuffered$: IValueSubject<boolean>;
+	protected readonly kind: StreamKind;
+	protected readonly nativeBufferManager: NativeBufferManager;
+	protected readonly fetcher: Fetcher;
+	protected readonly tracer: ITracer;
+	protected readonly tuning: ITuningConfig;
+	protected representations: Map<Representation["id"], Representation>;
+	protected playingRepresentationId: Representation["id"] | undefined;
+	protected downloadingRepresentationId: Representation["id"] | undefined;
+	protected switchingRepresentationId: Representation["id"] | null;
+	protected initData: Map<Representation["id"], ArrayBuffer>;
+	protected initDataPromises: Map<Representation["id"], Promise<RepresentationFetchResult<T> | null | undefined>>;
+	protected idleCallbacks: Map<Representation["id"], number>;
+	protected parsedInitData: Map<Representation["id"], CommonInit>;
+	protected forwardBufferRepresentations: Map<Representation["id"], T[]>;
+	protected segments: Map<Representation["id"], T[]>;
+	protected containerParser: ContainerParser;
+	protected bufferPlaybackQueue: IBufferPlaybackQueueItem<T>[];
+	protected downloadingBufferItems: IBufferPlaybackQueueItem<T>[];
+	protected preloadOnly: boolean;
+	protected forwardBufferTarget: Milliseconds;
+	protected failedDownloads: number;
+	protected lastDataObtainedTimestampMs: Milliseconds;
+	protected loadByteRangeSegmentsTimeoutId: number;
+	protected currentVirtualBufferSize: Byte;
+	private baseUrls;
+	private baseUrlsIndex;
+	protected maintainAbortController: AbortController;
+	protected maintainMutexPromise: Promise<void> | null;
+	protected bufferClearingMutex: boolean;
+	protected abortNativeBufferMutex: boolean;
+	protected switchMutex: boolean;
+	protected seekMutex: boolean;
+	protected destroyAbortController: AbortController;
+	protected switchAbortController: AbortController;
+	protected downloadAbortController: AbortController;
+	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 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;
+	protected abstract onSomeDataLoaded(data: ISomeDataLoadedCallbackParams<T>): Promise<void>;
+	protected abstract updateRepresentationBaseUrl(representation: Representation, newBaseUrl: string): void;
+	startWith: ReturnType<typeof abortable<[Representation["id"]]>>;
+	switchTo(newRepresentationId: Representation["id"], mode?: SwithRepresentationMode): Promise<void>;
+	protected getSwitchWithAbort(switchToTracer: ITracer): ReturnType<typeof abortable<[Representation["id"], SwithRepresentationMode], void>>;
+	prepareSeek(): Promise<void>;
+	seek(position: Milliseconds | undefined): Promise<void>;
+	maintain(currentPosition?: Milliseconds | undefined): Promise<void>;
+	getForwardBufferRepresentations(currentPosition?: Milliseconds | undefined): Map<Representation["id"], T[]>;
+	getForwardPlaybackBufferDuration(currentPosition?: Milliseconds | undefined): Milliseconds;
+	getPlaybackBufferState(): IRange<Milliseconds> | null;
+	abort(): Promise<void>;
+	findSegmentStartTime(position: Milliseconds): Milliseconds | undefined;
+	getRepresentationInitialTime(): Seconds;
+	getMutexInfo(): string;
+	calculateDurationFromSegments(): Milliseconds;
+	getActiveSegmentProgress(): VideoSegmentLoadProgress | undefined;
+	getMpdSegmentDuration(): Milliseconds | undefined;
+	get lastDataObtainedTimestamp(): Milliseconds;
+	setTarget(time: Milliseconds): void;
+	setPreloadOnly(preloadOnly: boolean): void;
+	destroy(): void;
+	protected verifyBufferPlaybackQueue(position: Milliseconds): Promise<void>;
+	protected forceSwitchCondition(oldRepresentation: Representation, newRepresentation: Representation): boolean;
+	protected clearBuffer(): Promise<void>;
+	protected abortDownload(): void;
+	protected abortDownloadingItems(): void;
+	protected abortNativeBuffer(): Promise<boolean>;
+	protected loadInits(): Promise<void>;
+	protected loadInitIfNeeded(representation: Representation, requestedPriority?: Priority, critical?: boolean): Promise<void>;
+	protected loadInit(representation: Representation, requestedPriority?: Priority, critical?: boolean): Promise<void>;
+	private isMaintainNativeBufferMutexActive;
+	protected maintainNativeBuffer(signal: AbortSignal): Promise<void>;
+	protected maintainPlaybackBuffer(position: Milliseconds): Promise<void>;
+	protected actualizeLastSegmentInfo(currentPosition: Milliseconds): void;
+	protected selectDownloadingItems(position: Milliseconds, segments: T[]): IBufferPlaybackQueueItem<T>[];
+	protected processCachedItems(): void;
+	protected withinInterval(currentPosition: Milliseconds | undefined, { from, to }: IRange<Milliseconds>, leftTolerance?: Milliseconds, rightTolerance?: Milliseconds): boolean;
+	protected withinAppendInterval(currentPosition: Milliseconds | undefined, { from, to }: IRange<Milliseconds>): boolean;
+	protected withinRemoveInterval(currentPosition: Milliseconds | undefined, { to }: IRange<Milliseconds>): boolean;
+	protected getExponentialDownloadDelay(): ReturnType<typeof abortable>;
+	protected waitExponentialDownloadDelay(): Promise<void>;
+	protected appendSegmentFully(nextPlayingItem: IBufferPlaybackQueueItem<T>, signal: AbortSignal): Promise<void>;
+	protected appendSegmentPartially(nextPlayingItem: IBufferPlaybackQueueItem<T>, signal: AbortSignal): Promise<void>;
+	protected parseFeedableSegmentChunk(chunk: DataView): DataView | null;
+	protected onItemFullyDownloaded(downloadedItem: IBufferPlaybackQueueItem<T>): void;
+	protected onItemFullyAppended(appendedItem: IBufferPlaybackQueueItem<T>): void;
+	protected removeSegment(nextRemoveItem: IBufferPlaybackQueueItem<T>, signal: AbortSignal): Promise<void>;
+	protected onDownloadItem(downloadedItem: IBufferPlaybackQueueItem<T>): void;
+	protected pruneVirtualBuffer(currentPosition: Milliseconds): void;
+	protected updateRepresentationsBaseUrlIfNeeded(): void;
+}

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

@@ -0,0 +1,21 @@
+import { BaseVirtualBufferManager } from "./baseVirtualBufferManager.versionA";
+import type { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackParams, IVirtualBufferManager } from "../types";
+import type { ByteRangeSegment, Representation, StreamKind } from "../../../../utils/parsers/types";
+import type { NativeBufferManager } from "../nativeBufferManager";
+import type { FetchParamsWithUrl, Priority } from "../../fetcher";
+export declare class ByteRangeVirtualBufferManager extends BaseVirtualBufferManager<ByteRangeSegment> implements IVirtualBufferManager<ByteRangeSegment> {
+	constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies);
+	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;
+	/**
+	* Закидываем в буфер сегменты атомарнее чем сегмент целиком. Например, по боксам в мпеге и по блокам в вебме.
+	* Таким образом не ждём его полной загрузки и готовы играть его намного быстрее
+	* @param dataView – данные, размер буфера – весь запрос
+	* @param globalFrom – Отступ dataView от начала файла, совпадает с отсупами сегментов
+	* @param loaded – Объём загруженных в dataView данных (всё что больше – пока нули)
+	* @private
+	*/
+	protected override onSomeDataLoaded({ downloadingItems, dataView, representationId, globalFrom, loaded, signal }: ISomeDataLoadedCallbackParams<ByteRangeSegment>): Promise<void>;
+	protected override updateRepresentationBaseUrl(representation: Representation, newBaseUrl: string): void;
+}

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

@@ -0,0 +1,21 @@
+import { BaseVirtualBufferManager } from "./baseVirtualBufferManager.versionA";
+import type { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackParams, IVirtualBufferManager } from "../types";
+import type { TemplateSegment, Representation, StreamKind } from "../../../../utils/parsers/types";
+import type { NativeBufferManager } from "../nativeBufferManager";
+import type { FetchParamsWithUrl, Priority } from "../../fetcher";
+export declare class TemplateVirtualBufferManager extends BaseVirtualBufferManager<TemplateSegment> implements IVirtualBufferManager<TemplateSegment> {
+	constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies);
+	protected override loadItems(itemsToLoad: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation, priority?: Priority): Promise<void>;
+	protected override selectItemsToLoad(): IBufferPlaybackQueueItem<TemplateSegment>[];
+	protected override prepareFetchParams(items: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation): FetchParamsWithUrl;
+	protected getFetchUrl(items: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation): URL;
+	/**
+	* Закидываем в буфер сегменты атомарнее чем сегмент целиком. Например, по боксам в мпеге и по блокам в вебме.
+	* Таким образом не ждём его полной загрузки и готовы играть его намного быстрее
+	* @param dataView – данные, размер буфера – весь запрос
+	* @param loaded – Объём загруженных в dataView данных (всё что больше – пока нули)
+	* @private
+	*/
+	protected override onSomeDataLoaded({ downloadingItems, dataView, representationId, loaded, signal }: ISomeDataLoadedCallbackParams<TemplateSegment>): Promise<void>;
+	protected override updateRepresentationBaseUrl(representation: Representation, newBaseUrl: string): void;
+}

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

@@ -1,6 +1,7 @@
 import type { Representation, StreamKind } from "../../../../utils/parsers/types";
 import type { NativeBufferManager } from "../nativeBufferManager";
 import type { Dependencies, IVirtualBufferManager } from "../types";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
 export declare class VirtualBufferFactory {
-	static getBufferManager(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies): IVirtualBufferManager;
+	static getBufferManager(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies, tuning: ITuningConfig): IVirtualBufferManager;
 }

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

@@ -25,6 +25,8 @@ export interface IParams {
 	handleExtendedNetworkErrorsSet?: boolean;
 	useUrlCacheMechanism?: boolean;
 	measureNonSegmentRequests?: boolean;
+	measureFastSamples?: boolean;
+	preloadFirstSegment?: boolean;
 }
 export type Priority = "high" | "low" | "auto";
 export interface FetchParamsWithUrl extends FetchParams {
@@ -46,6 +48,7 @@ export type RepresentationFetchResult<T extends Segment> = {
 	initMetadata: CommonInit | null;
 	initDataView: DataView;
 	segments: T[];
+	firstSegmentData?: ArrayBuffer;
 };
 export declare class Fetcher {
 	private throughputEstimator;
@@ -68,11 +71,13 @@ export declare class Fetcher {
 	private useEnableSubtitlesParam;
 	private useUrlCacheMechanism;
 	private measureNonSegmentRequests;
+	private measureFastSamples;
+	private preloadFirstSegment;
 	private startupPhase;
 	private performanceObserver;
 	private pendingConnectionMetrics;
 	private handleExtendedNetworkErrorsSet;
-	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, useUrlCacheMechanism, measureNonSegmentRequests }: IParams);
+	constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam, handleExtendedNetworkErrorsSet, useUrlCacheMechanism, measureNonSegmentRequests, measureFastSamples, preloadFirstSegment }: IParams);
 	private onHeadersReceived;
 	private setupPerformanceObserver;
 	private processResourceTiming;
@@ -86,5 +91,6 @@ export declare class Fetcher {
 	destroy(): void;
 	private fetchByteRangeRepresentation;
 	private fetchTemplateRepresentation;
+	private isLikelyCacheHitByTtfb;
 	private doFetch;
 }

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

@@ -1,19 +1,20 @@
+import { Subject } from "@vkontakte/videoplayer-shared";
 import type { IError } from "@vkontakte/videoplayer-shared";
-import type { IMaydayDeps, IRecommendation } from "./types";
+import type { IMaydayDeps, IMaydayEvent } from "./types";
 export declare class MaydayService {
 	private deps;
 	private heuristics;
 	private tracer;
 	private providerFailures;
 	private failoverUrlIndex;
+	readonly recommendation$: Subject<IMaydayEvent>;
+	private subscription;
 	constructor(deps: IMaydayDeps);
 	get currentFailoverUrlIndex(): number | undefined;
-	getRecommendation(error: IError): IRecommendation;
+	handleError(error: IError): void;
+	private emitRecommendation;
 	private validateRecommendation;
 	private hasAvailableFailoverHost;
-	/**
-	* Если рекомендаций от эвристик нету, то идем по общему сценарию.
-	*/
 	private computeFallbackRecommendation;
 	private applyStateChange;
 	reset(): void;

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

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

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

@@ -0,0 +1,22 @@
+import type { IError } from "@vkontakte/videoplayer-shared";
+import type { IHeuristicDeps } from "../types";
+import type { IAsyncHeuristic, HeuristicResult } from "./IHeuristic";
+export declare class HangupHeuristic implements IAsyncHeuristic {
+	private deps;
+	static readonly heuristicName = "HangupHeuristic";
+	readonly type = "async";
+	readonly recommendation$;
+	private timerId;
+	private sub;
+	private error;
+	private manifestRequested;
+	private manifestRequestedAt;
+	private manifestReceivedMs;
+	constructor(deps: IHeuristicDeps);
+	analyze(error: IError): HeuristicResult;
+	private restartTimer;
+	private expire;
+	private cancel;
+	reset(): void;
+	destroy(): void;
+}

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

@@ -1,7 +1,17 @@
-import type { IError } from "@vkontakte/videoplayer-shared";
-import type { IRecommendation } from "../types";
-export interface IHeuristic {
-	analyze(error: IError): IRecommendation | null;
+import type { IError, ISubject } from "@vkontakte/videoplayer-shared";
+import type { IMaydayEvent, IRecommendation } from "../types";
+export type HeuristicResult = IRecommendation | null;
+interface IHeuristicBase {
+	analyze(error: IError): HeuristicResult;
 	reset?(): void;
 	destroy?(): void;
 }
+export interface ISyncHeuristic extends IHeuristicBase {
+	readonly type: "sync";
+}
+export interface IAsyncHeuristic extends IHeuristicBase {
+	readonly type: "async";
+	readonly recommendation$: ISubject<IMaydayEvent>;
+}
+export type IHeuristic = ISyncHeuristic | IAsyncHeuristic;
+export {};

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

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

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

@@ -1,6 +1,7 @@
 export { MaydayService } from "./MaydayService";
-export type { IMaydayDeps, IFallbackContext, IRecommendation, RecoveryAction } from "./types";
-export type { IHeuristic } from "./heuristics/IHeuristic";
+export type { IMaydayDeps, IFallbackContext, IRecommendation, RecoveryAction, IMaydayEvent } from "./types";
+export type { ISyncHeuristic, IAsyncHeuristic, HeuristicResult } from "./heuristics/IHeuristic";
 export { MediaErrorHeuristic } from "./heuristics/MediaErrorHeuristic";
 export { FetcherErrorHeuristic } from "./heuristics/FetcherErrorHeuristic";
+export { HangupHeuristic } from "./heuristics/HangupHeuristic";
 export { MaydayStatistics } from "./MaydayStatistics";

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

@@ -0,0 +1,21 @@
+import { Subject } from "@vkontakte/videoplayer-shared";
+import type { ITracer } from "@vkontakte/videoplayer-shared";
+import { PlaybackState } from "../../../player/types";
+import type { ITransition } from "../../../utils/StateMachine/types";
+import type { IHeuristicDeps, IMaydayProviderOutput, IMaydayDeps } from "./types";
+export declare function createMockTracer(): ITracer;
+export declare function createMockProviderOutput(overrides?: Partial<IMaydayProviderOutput>): IMaydayProviderOutput;
+export declare function createMockDesiredPlaybackState$(): {
+	stateChangeStarted$: Subject<unknown>;
+	stateChangeEnded$: Subject<ITransition<PlaybackState>>;
+	transitionEnded$: Subject<unknown>;
+	getState: () => PlaybackState;
+};
+export declare function createMockHeuristicDeps(params?: {
+	overrides?: Partial<IHeuristicDeps>;
+	tuningOverrides?: Record<string, unknown>;
+}): IHeuristicDeps;
+export declare function createMockMaydayDeps(params?: {
+	overrides?: Partial<IMaydayDeps>;
+	tuningOverrides?: Record<string, unknown>;
+}): IMaydayDeps;

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

@@ -1,5 +1,6 @@
-import type { IVideoTrack, IVideoStream, IAudioStream } from "../../../player/types";
-import type { IValueSubject, Milliseconds, Seconds, IRange, ITracer } from "@vkontakte/videoplayer-shared";
+import type { IVideoTrack, IVideoStream, IAudioStream, PlaybackState } from "../../../player/types";
+import type { IError, IValueSubject, ISubject, IObservable, Milliseconds, Seconds, IRange, ITracer } from "@vkontakte/videoplayer-shared";
+import type { IStateMachine } from "../../../utils/StateMachine/types";
 import type { ITuningConfig } from "../../../utils/tuningConfig";
 export interface IFallbackContext {
 	hasProviderStarted: boolean;
@@ -17,11 +18,17 @@ export interface IMaydayProviderOutput {
 	bufferRangeCount$: IValueSubject<number | undefined>;
 	availableVideoStreams$: IValueSubject<IVideoStream[]>;
 	currentAudioStream$: IValueSubject<IAudioStream | undefined>;
+	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds | undefined>;
+	soundProhibitedEvent$: ISubject<void>;
+	element$: IValueSubject<HTMLVideoElement | undefined>;
+	manifestRequested$: IObservable<void>;
+	manifestReceived$: IObservable<void>;
 }
 export interface IMaydayDeps {
 	tuning: ITuningConfig;
 	failoverHosts: string[];
 	providerOutput: IMaydayProviderOutput;
+	desiredPlaybackState$: IStateMachine<PlaybackState>;
 	maydayStatistics: {
 		getInitiatedAt: () => number;
 		getReinitHistory: () => IReinitHistory;
@@ -45,9 +52,20 @@ export interface IHeuristicDeps {
 	getVideoCodec: () => string | undefined;
 	getAudioCodec: () => string | undefined;
 	getVisibilityState: () => DocumentVisibilityState | undefined;
+	getReadyState: () => number | undefined;
+	getVideoPaused: () => boolean | undefined;
+	currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds | undefined>;
+	desiredPlaybackState$: IStateMachine<PlaybackState>;
+	manifestRequested$: IObservable<void>;
+	manifestReceived$: IObservable<void>;
 }
-export type RecoveryAction = "reinit" | "failover_host" | "switch_codec" | "switch_provider";
+export type RecoveryAction = "reinit" | "failover_host" | "switch_codec" | "switch_provider" | "wait";
 export interface IRecommendation {
 	action: RecoveryAction;
 	reason: string;
 }
+export interface IMaydayEvent {
+	error: IError;
+	recommendation: IRecommendation;
+}

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

@@ -49,6 +49,7 @@ export type ByteRangeSegmentReference = {
 	url: string;
 	initRange: IRange<Byte>;
 	indexRange?: IRange<Byte>;
+	firstSegmentLength?: Byte;
 };
 export type TemplateSegmentReference = {
 	type: SegmentReferencingType.TEMPLATE;

package/types/utils/tuningConfig.d.ts

@@ -43,6 +43,25 @@ export type ITuningConfig = {
 		measureNonSegmentRequests: boolean;
 		smallSampleMinDuration: Milliseconds;
 		cacheThresholdSize: Milliseconds;
+		/**
+		* Фичафлаг UVP-10855: лечит залипание throughput на быстрых соединениях.
+		*
+		* Проблема: на быстром соединении крупный сегмент реально скачивается за ≤ cacheThresholdSize
+		* (например 200 КБ за 10 мс = 160 Мбит/с), а sanityCheck режет такие сэмплы как «кэш».
+		* Промежуточных сэмплов нет (нужно streamMinSampleTime=300 мс), поэтому эстиматор не получает
+		* ни одного значения, throughput стоит на стартовой оценке → ABR не поднимает качество
+		* (мелкие сегменты качаются быстро → замкнутый круг).
+		*
+		* При true:
+		* 1. Фетчер детектит кэш-хиты двумя сигналами (OR) и НЕ измеряет их:
+		*    - fromCache — попадание в Cache API (doFetch дёргает onCacheHit);
+		*    - TTFB — headersReceivedAt - requestStartedAt < max(rtt*0.5, 2мс) (кэш ~0, реал ≥ RTT).
+		* 2. sanityCheck отключает порог time ≤ cacheThresholdSize → реальные быстрые сэмплы проходят.
+		* Честный кэш (мгновенная отдача → rate > 1 Гбит/с) по-прежнему режется проверкой rate выше.
+		*
+		* По умолчанию false — поведение не меняется.
+		*/
+		measureFastSamples: boolean;
 		rttPenaltyRequestSize: Byte;
 		streamMinSampleSize: Byte;
 		streamMinSampleTime: Milliseconds;
@@ -156,6 +175,7 @@ export type ITuningConfig = {
 		virtualBufferEmptinessTolerance: Milliseconds;
 		useBufferQueueVerification: boolean;
 		useVirtualBufferImplicitSeek: boolean;
+		bufferQueueVerificationMinPosition: Milliseconds;
 		useNewRepresentationSwitch: boolean;
 		useDelayedRepresentationSwitch: boolean;
 		useSmartRepresentationSwitch: boolean;
@@ -231,6 +251,7 @@ export type ITuningConfig = {
 		filterOnDemandQualityList: boolean;
 		dashMaxTvVideoQuality: boolean;
 		checkRepresentationCanPlayType: Extract<CanPlayTypeResult, "maybe" | "probably"> | false;
+		preloadFirstSegment: boolean;
 		downloadTime: {
 			minLookaheadSegments: number;
 			safetyFactor: number;
@@ -311,6 +332,7 @@ export type ITuningConfig = {
 	dashSeekInSegmentAlwaysSeekDelta: Milliseconds;
 	useDelayedPlaybackHangupWithData: boolean;
 	playbackHangupNoDataThreshold: Milliseconds;
+	hangupTimeoutMs: Milliseconds;
 	endGapTolerance: Milliseconds;
 	/**
 	* Время после перехода в состояние buffering, когда мы считаем что происходит stall
@@ -332,6 +354,7 @@ export type ITuningConfig = {
 	useNewSwitchTo: boolean;
 	alwaysAbortPreviousSwitch: boolean;
 	useDashProviderVirtual: boolean;
+	useDashProviderVirtualVersionA: boolean;
 	useDashProviderVirtualMobile: boolean;
 	useNewAutoSelectVideoTrack: boolean;
 	useSafariEndlessRequestBugfix: boolean;