@vkontakte/videoplayer-core 2.0.172-dev.ecd203d9a.0 → 2.0.173-dev.ebda080eb.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.172-dev.ecd203d9a.0",
+  "version": "2.0.173-dev.ebda080eb.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.101-dev.ecd203d9a.0"
+    "@vkontakte/videoplayer-shared": "1.0.102-dev.ebda080eb.0"
   }
 }

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

@@ -42,6 +42,7 @@ export declare class BufferManager {
 	private parsedInitData;
 	private representations;
 	private segments;
+	private segmentIndexMap;
 	private allInitsLoaded;
 	private activeSegments;
 	private forwardBufferRepresentations;
@@ -109,6 +110,7 @@ export declare class BufferManager {
 	private feedPreDownloadedFirstSegment;
 	private loadByteRangeSegments;
 	private prepareByteRangeFetchSegmentParams;
+	private buildCacheMetadata;
 	private prepareTemplateFetchSegmentParams;
 	private abortActiveSegments;
 	private onSomeTemplateDataLoaded;

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;
@@ -93,6 +95,8 @@ export declare class Fetcher {
 	fetchManifest: ReturnType<typeof abortable<[string], string | null>>;
 	fetch: ReturnType<typeof abortable<[string, FetchParams], ArrayBuffer | null>>;
 	fetchRepresentation(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, fetchParams: FetchParams): Promise<RepresentationFetchResult | null>;
+	/** Скипнутые сегменты не записаны в кэш — при следующем запросе региона докачаются как miss. */
+	private traceSkippedCacheSegments;
 	destroy(): void;
 	private fetchByteRangeRepresentation;
 	private fetchTemplateRepresentation;

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;
@@ -53,7 +55,7 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected readonly getCurrentPosition: () => Milliseconds | undefined;
 	protected readonly getCurrentStallDuration: () => Milliseconds | undefined;
 	protected brokenSegmentAppendDetected: boolean;
-	protected constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], { fetcher, tracer, tuning, getCurrentPosition, getCurrentStallDuration, manifest }: Dependencies);
+	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;

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;
@@ -92,6 +94,8 @@ export declare class Fetcher {
 	fetchManifest: ReturnType<typeof abortable<[string], string | null>>;
 	fetch: ReturnType<typeof abortable<[string, FetchParams], ArrayBuffer | null>>;
 	fetchRepresentation<T extends Segment>(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, dowbloadAbortSignal: AbortSignal, priority?: Priority, representationHeight?: number, kind?: StreamKind): Promise<RepresentationFetchResult<T> | null | undefined>;
+	/** Скипнутые сегменты не записаны в кэш — при следующем запросе региона докачаются как miss. */
+	private traceSkippedCacheSegments;
 	destroy(): void;
 	private fetchByteRangeRepresentation;
 	private fetchTemplateRepresentation;

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;

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/utils/segmentCache/IndexedDbSegmentCacheStorage.d.ts

@@ -0,0 +1,54 @@
+import type { InitSegmentParams, ISegmentCacheStorage, SegmentCacheConfig, SetSegmentParams } from "./types";
+export declare class IndexedDbSegmentCacheStorage implements ISegmentCacheStorage {
+	private config;
+	private dbPromise;
+	private destroyed;
+	private evictionTimerId;
+	private globalTotalBytes;
+	private maxTotalStoredBytes;
+	private quotaExceeded;
+	private cacheEventsChannel;
+	constructor(config: SegmentCacheConfig);
+	private getDb;
+	private isFresh;
+	/**
+	* Читает записи по массиву ключей в одной транзакции.
+	* Свежие по TTL — возвращает данные и обновляет lastAccessAt (не чаще чем раз в TOUCH_INTERVAL_MS,
+	* чтобы избежать write amplification: каждый cache hit не должен делать store.put с полным ArrayBuffer).
+	* Протухшие — удаляет, декрементирует globalTotalBytes.
+	*/
+	private readFreshRecord;
+	/**
+	* При открытии БД пересчитывает globalTotalBytes: проходит по всем записям,
+	* суммирует размер живых (не протухших по TTL) и удаляет протухшие.
+	* TTL различается: media — ttlMs, init/index — initTtlMs.
+	*/
+	private handleDbOpened;
+	/** Возвращает TTL в зависимости от типа записи по первичному ключу. */
+	private ttlForEntry;
+	getSegments(normalizedUrl: string, indices: number[]): Promise<Map<number, ArrayBuffer>>;
+	/** Удаляет записи по индексам сегментов в одной транзакции, декрементируя globalTotalBytes. */
+	deleteSegments(normalizedUrl: string, indices: number[]): Promise<void>;
+	setSegment(params: SetSegmentParams): Promise<void>;
+	getInitSegment({ normalizedUrl, rangeType, range }: InitSegmentParams): Promise<ArrayBuffer | null>;
+	/** Универсальная запись с подсчётом delta, QuotaExceededError-обработкой и eviction. */
+	private putRecord;
+	private handleQuotaExceededError;
+	/** Полная очистка кэша с рассылкой события остальным инстансам (вкладки, другие плееры). */
+	clear(): Promise<void>;
+	destroy(): void;
+	private scheduleEviction;
+	/**
+	* LRU-eviction: запускается по дебаунсу после каждой записи.
+	* Без квоты — триггерит при достижении maxTotalStoredBytes.
+	* После QuotaExceededError — раньше, на maxTotalStoredBytes * evictionThreshold,
+	* чтобы не упереться в квоту повторно.
+	* Очищает с запасом — до maxTotalStoredBytes * evictionTargetPercent.
+	*/
+	private runEviction;
+	/**
+	* Удаляет самые старые по lastAccessAt записи, пока не освободит хотя бы bytesToFree.
+	* maxBytesPerBatch ограничивает длительность одной транзакции; без лимита — при QuotaExceededError.
+	*/
+	private evictOldest;
+}

package/types/providers/utils/segmentCache/SegmentCache.d.ts

@@ -0,0 +1,59 @@
+import type { ISegmentCacheStorage, CacheMetadata, CacheMetadataEntry } from "./types";
+import type { SubRange } from "./segmentCacheUtils";
+export declare enum CacheCheckResultType {
+	FullHit = "full_hit",
+	FullMiss = "full_miss",
+	Partial = "partial"
+}
+export type CacheCheckResult = {
+	type: CacheCheckResultType.FullHit;
+	data: ArrayBuffer;
+} | {
+	type: CacheCheckResultType.FullMiss;
+} | {
+	type: CacheCheckResultType.Partial;
+	cached: Map<number, ArrayBuffer>;
+	missingRange: SubRange;
+	startBuffer: {
+		buffer: ArrayBuffer;
+		loaded: number;
+	} | null;
+};
+export declare class SegmentCache {
+	private cacheService;
+	constructor(cacheService: ISegmentCacheStorage);
+	getCached(url: string, metadata: CacheMetadata): Promise<CacheCheckResult>;
+	/**
+	* Длина записи обязана совпадать с byteRange сегмента: и сборка (assembleFromCached склеивает
+	* конкатенацией, assembleStartBuffer — по абсолютным смещениям), и кормление буфера адресуют
+	* сегменты по этим смещениям. Битая запись сдвигает/зануляет весь батч после себя.
+	* Расхождение = отрава: считаем miss и удаляем ключ — сегмент перекачается и перезапишется.
+	*/
+	private dropCorruptedEntries;
+	storeDownloadedSegments({ url, buffer, segments, networkDataOffset, validBytes, onSkipped }: {
+		url: string;
+		buffer: ArrayBuffer;
+		segments: CacheMetadataEntry[];
+		networkDataOffset?: number;
+		/**
+		* Сколько байт в начале buffer содержат реальные данные.
+		* Может быть меньше buffer.byteLength — при пре-аллокации (bufferOptimisation) хвост буфера остаётся нулями.
+		*/
+		validBytes?: number;
+		/**
+		* Вызывается, если часть сегментов не влезла в validBytes: они не записаны в кэш
+		* и докачаются как miss при следующем запросе региона.
+		*/
+		onSkipped?: (segments: CacheMetadataEntry[]) => void;
+	}): void;
+	private assembleStartBuffer;
+	private buildPartialFromCacheStart;
+	storeMissing({ url, missingRange, networkData, networkDataOffset, validBytes, onSkipped }: {
+		url: string;
+		missingRange: SubRange;
+		networkData: ArrayBuffer;
+		networkDataOffset?: number;
+		validBytes?: number;
+		onSkipped?: (segments: CacheMetadataEntry[]) => void;
+	}): void;
+}

package/types/providers/utils/segmentCache/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const DB_NAME = "vk_player_segment_cache";
+export declare const DB_VERSION = 1;
+export declare const STORE = "cache";
+export declare const EVICTION_DEBOUNCE_MS = 5e3;
+/** Канал синхронизации инстансов storage (вкладки, несколько плееров на странице) */
+export declare const CACHE_EVENTS_CHANNEL = "vk_player_segment_cache_events";
+/** Событие полной очистки кэша: получатель сбрасывает in-memory счётчик байт, база уже пуста */
+export declare const CACHE_CLEARED_EVENT = "cleared";
+/**
+* Минимальный интервал между обновлениями lastAccessAt при чтении.
+* Без него каждый cache hit делал бы store.put с полным ArrayBuffer ради одного поля.
+* При TTL в часы точность LRU до минут не нужна — 5 минут достаточно.
+*/
+export declare const TOUCH_INTERVAL_MS: number;
+/** Тип записи: media-сегмент, init-сегмент, index-сегмент */
+export declare enum CacheEntryType {
+	Media = 0,
+	Init = 1,
+	Index = 2
+}

package/types/providers/utils/segmentCache/index.d.ts

@@ -0,0 +1,8 @@
+export { IndexedDbSegmentCacheStorage } from "./IndexedDbSegmentCacheStorage";
+export { SegmentCache, CacheCheckResultType } from "./SegmentCache";
+export type { CacheCheckResult } from "./SegmentCache";
+export { normalizeSegmentCacheUrl, assemblePartialBuffer, toEntryType, createMediaKey, createInitKey, isQuotaExceededError } from "./segmentCacheUtils";
+export type { SubRange } from "./segmentCacheUtils";
+export { clearSegmentCacheDb } from "./segmentCacheDb";
+export { DB_NAME, DB_VERSION, STORE, EVICTION_DEBOUNCE_MS, CacheEntryType } from "./constants";
+export type { ISegmentCacheStorage, CacheMetadata, CacheMetadataEntry, SegmentCacheConfig, SegmentCacheEntry, InitSegmentParams, InitSegmentRangeType, SetMediaSegmentParams, SetInitSegmentParams, SetSegmentParams, CacheRecord, CachePrimaryKey } from "./types";

package/types/providers/utils/segmentCache/segmentCacheDb.d.ts

@@ -0,0 +1,25 @@
+export declare const INDEX_BY_LAST_ACCESS = "byLastAccess";
+export declare const INDEX_BY_SIZE_AND_AGE = "bySizeAndAge";
+export declare const INDEX_BY_LAST_ACCESS_AND_SIZE = "byLastAccessAndSize";
+/**
+* Открывает базу кэша, при первом создании поднимает store и индексы.
+* onOpened (если передан) await-ится до resolve — используется только в clearSegmentCacheDb.
+* Инстанс storage не использует onOpened: rehydrate запускается параллельно, чтобы не блокировать чтения.
+*/
+export declare const openSegmentCacheDb: (onOpened?: (db: IDBDatabase) => Promise<void>) => Promise<IDBDatabase>;
+/** Выполняет операции в одной readwrite-транзакции, резолвится по её завершении. */
+export declare const execStoreTx: (db: IDBDatabase, body: (store: IDBObjectStore) => void) => Promise<void>;
+/**
+* Гоняет курсор по индексу, вызывая visit на каждой записи.
+* visit возвращает false — итерация останавливается, транзакция завершается.
+* Работает только внутри execStoreTx: завершение итерации отслеживается транзакцией.
+*/
+export declare const iterateCursor: <T extends IDBCursor>(request: IDBRequest<T | null>, visit: (cursor: T) => boolean) => void;
+/** Рассылает событие полной очистки кэша всем инстансам storage (вкладки, другие плееры на странице). */
+export declare const broadcastCacheCleared: () => void;
+/**
+* Полностью очищает кэш без привязки к инстансу storage: можно звать из мест,
+* где экземпляр IndexedDbSegmentCacheStorage недоступен (например, из ProviderContainer при ошибках).
+* Живые инстансы узнают об очистке через broadcastCacheCleared и сбросят in-memory счётчики.
+*/
+export declare const clearSegmentCacheDb: () => Promise<void>;

package/types/providers/utils/segmentCache/segmentCacheUtils.d.ts

@@ -0,0 +1,25 @@
+import type { Byte, IRange } from "@vkontakte/videoplayer-shared";
+import type { CacheMetadata, CacheMetadataEntry, InitSegmentRangeType, CachePrimaryKey } from "./types";
+import { CacheEntryType } from "./constants";
+/** Приводит URL к каноническому виду: заменяет hostname на cache.local и удаляет CDN-параметры (sig, expires, bytes, fromCache). */
+export declare function normalizeSegmentCacheUrl(url: string): string;
+export declare function toEntryType(rangeType: InitSegmentRangeType): CacheEntryType;
+export declare function createMediaKey(normalizedUrl: string, segmentIndex: number): CachePrimaryKey;
+export declare function createInitKey(normalizedUrl: string, entryType: CacheEntryType, rangeFrom: number, rangeTo: number): CachePrimaryKey;
+export declare function isQuotaExceededError(error: unknown): boolean;
+export type SubRange = {
+	range: IRange<Byte>;
+	segments: CacheMetadataEntry[];
+};
+/** Проверяет, что сегменты идут подряд по индексам — без разрывов между ними. Ожидает отсортированный массив. */
+export declare function isContiguous(segments: CacheMetadataEntry[]): boolean;
+/** Склеивает буферы закэшированных сегментов в один ArrayBuffer. Используется при full hit. */
+export declare function assembleFromCached(metadata: CacheMetadata, cached: Map<number, ArrayBuffer>): ArrayBuffer;
+/** Склеивает закэшированные и сетевые данные в один ArrayBuffer для partial hit. */
+export declare function assemblePartialBuffer({ metadata, cached, missingRange, networkData, networkDataOffset }: {
+	metadata: CacheMetadata;
+	cached: Map<number, ArrayBuffer>;
+	missingRange: SubRange;
+	networkData: ArrayBuffer;
+	networkDataOffset?: number;
+}): ArrayBuffer;

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

@@ -0,0 +1,76 @@
+import type { Byte, IRange } from "@vkontakte/videoplayer-shared";
+import type { CacheEntryType } from "./constants";
+export type InitSegmentRangeType = "init" | "index";
+export interface SegmentCacheEntry {
+	data: ArrayBuffer;
+	segmentIndex: number;
+}
+export interface InitSegmentParams {
+	normalizedUrl: string;
+	rangeType: InitSegmentRangeType;
+	range: IRange<Byte>;
+}
+export interface SetMediaSegmentParams {
+	type: "media";
+	normalizedUrl: string;
+	segmentIndex: number;
+	data: ArrayBuffer;
+}
+export interface SetInitSegmentParams {
+	type: "init";
+	normalizedUrl: string;
+	rangeType: InitSegmentRangeType;
+	range: IRange<Byte>;
+	data: ArrayBuffer;
+}
+export type SetSegmentParams = SetMediaSegmentParams | SetInitSegmentParams;
+export interface ISegmentCacheStorage {
+	getSegments(normalizedUrl: string, indices: number[]): Promise<Map<number, ArrayBuffer>>;
+	setSegment(params: SetSegmentParams): Promise<void>;
+	/** Удаляет media-записи по индексам сегментов. Используется для самолечения: запись с несовпадающей длиной удаляется и сегмент перекачивается */
+	deleteSegments(normalizedUrl: string, indices: number[]): Promise<void>;
+	getInitSegment(params: InitSegmentParams): Promise<ArrayBuffer | null>;
+	/** Полная очистка кэша (все записи, без привязки к url) с рассылкой события другим инстансам */
+	clear(): Promise<void>;
+	destroy(): void;
+}
+export interface CacheMetadataEntry {
+	index: number;
+	byteRange: IRange<Byte>;
+}
+export interface CacheMetadata {
+	segments: CacheMetadataEntry[];
+}
+export interface SegmentCacheConfig {
+	/** Включает кэширование media-сегментов в IndexedDB */
+	enabled: boolean;
+	/** Лимит суммарного размера кэша (media + init/index сегменты) в байтах. При QuotaExceededError автоматически опускается до текущего размера */
+	maxTotalSizeBytes: number;
+	/** Доля от эффективного лимита, при превышении которой запускается LRU-эвикт (0.9 = 90%) */
+	evictionThreshold: number;
+	/** Доля от максимального хранимого кэша, до которой LRU-эвикт очищает кэш (0.7 = 70%).
+	*  Должна быть ниже evictionThreshold: запас между ними не даёт эвикту срабатывать на каждую запись у границы лимита
+	* */
+	evictionTargetPercent: number;
+	/** Максимальный объём данных в байтах, который LRU-эвикт удаляет за один проход (ограничивает длительность одной транзакции) */
+	evictionBatchMaxBytes: number;
+	/** Доля от maxTotalStoredBytes, которую нужно освободить при QuotaExceededError (0.5 = 50%) */
+	quotaExceededEvictPercent: number;
+	/** TTL для media-сегментов в миллисекундах. Протухшие записи удаляются при чтении и при rehydrate */
+	ttlMs: number;
+	/** TTL для init/index-сегментов в миллисекундах (обычно длиннее, т.к. они стабильнее) */
+	initTtlMs: number;
+	/** Стратегия очистки кэша при ошибках декодера/фетчера: 'once' — один раз за жизнь контейнера, 'always' — на каждую ошибку */
+	clearOnErrorStrategy: "once" | "always";
+}
+/**
+* Единая запись кэша. Ключ передаётся явно (out-of-line) через createMediaKey / createInitKey.
+*/
+export interface CacheRecord {
+	normalizedUrl: string;
+	data: ArrayBuffer;
+	byteLength: number;
+	createdAt: number;
+	lastAccessAt: number;
+}
+export type CachePrimaryKey = [string, CacheEntryType, number, number];

package/types/utils/tuningConfig.d.ts

@@ -5,6 +5,7 @@ import { IOSPreferredFormat } from "../enums/IOSPreferredFormat";
 import type { Byte, Kbps, Milliseconds, RecursivePartial, Seconds, TimerModule } from "@vkontakte/videoplayer-shared";
 import { type ExactVideoQuality, VideoQuality } from "@vkontakte/videoplayer-shared";
 import { AudioRuleName, VideoRuleName } from "../providers/utils/Abr/types";
+import type { SegmentCacheConfig } from "../providers/utils/segmentCache/types";
 export type ITuningConfig = {
 	/** @deprecated */
 	configName?: string[];
@@ -439,15 +440,6 @@ export type ITuningConfig = {
 	*/
 	handleExtendedNetworkErrorsSet?: boolean;
 	/**
-	* Кэшируем ответы от сервера руками, так как из за динамичесокй природы некоторых параметров в урле
-	* браузер это не может сделать.
-	*/
-	useUrlCacheMechanism?: boolean;
-	/**
-	* Очищаем кэш урлов при падение провайдера.
-	*/
-	dropUrlCacheWhenProviderCrashed?: boolean;
-	/**
 	* При смене/реините провайдера игнорируем результат того, смогло видео заиграть или нет.
 	*/
 	ignoreForcePlayResultWhenProviderChanged?: boolean;
@@ -475,6 +467,7 @@ export type ITuningConfig = {
 	* провайдер по-прежнему ждёт canplay, чтобы play() не вызывался до появления данных.
 	*/
 	readyOnLoadedMetadata: boolean;
+	segmentCache: SegmentCacheConfig;
 };
 export type IOptionalTuningConfig = RecursivePartial<ITuningConfig>;
 export declare const fillDefault: (partial: IOptionalTuningConfig) => ITuningConfig;

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

@@ -1,23 +0,0 @@
-export type CacheManager = {
-	get: () => Promise<Response | null>;
-	set: (response: Response) => void;
-};
-/**
-* Пытаемся добиться кэширования вызовов.
-* Сейчас есть проблема, что expires и sig меняются, хотя контент не меняется, поэтому ходим мимо кэша.
-* Из за этого обрабатываем кэш вручную.
-*/
-export declare const createCacheManager: (url: string) => Promise<CacheManager>;
-export declare function canUseCacheApi(): boolean;
-export declare function normalizeUrl(url: string): string;
-/**
-* Проверяет, не просрочен ли кэшированный ответ
-*/
-export declare function isResponseExpired(response: Response): boolean;
-export declare function cloneResponse(response: Response, url: string): Response;
-/**
-* Извлекает expires из оригинального URL (параметр expires1)
-* Предполагается, что expires1 — timestamp в секундах
-*/
-export declare function getExpiresFromUrl(url: string): number;
-export declare const dropUrlsCache: () => Promise<void>;

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

@@ -1,22 +0,0 @@
-export type CacheManager = {
-	get: () => Promise<Response | null>;
-	set: (response: Response) => Promise<void>;
-};
-/**
-* Пытаемся добиться кэширования вызовов.
-* Сейчас есть проблема, что expires и sig меняются, хотя контент не меняется, поэтому ходим мимо кэша.
-* Из за этого обрабатываем кэш вручную.
-*/
-export declare const createCacheManager: (url: string) => Promise<CacheManager>;
-export declare function canUseCacheApi(): boolean;
-export declare function normalizeUrl(url: string): string;
-/**
-* Проверяет, не просрочен ли кэшированный ответ
-*/
-export declare function isResponseExpired(response: Response): boolean;
-export declare function cloneResponse(response: Response, url: string): Response;
-/**
-* Извлекает expires из оригинального URL (параметр expires1)
-* Предполагается, что expires1 — timestamp в секундах
-*/
-export declare function getExpiresFromUrl(url: string): number;