@aelionsdk/sdk 0.1.0-beta.1

package/dist/production-media-provider.js

@@ -0,0 +1,749 @@
+import { throwIfAborted } from '@aelionsdk/core';
+import { BlobRangeReader, FetchRangeReader, MemoryCacheStore, PageMediaResourceGovernor, createSampleIndexFromReader, createVideoFrameDecodeSessionFromReader, decodeAudioPcmRangeFromReader, decodeStillImageFromReader, decodeVideoFrameAtFromReader, proxyPresentationTimeUs, selectAssetRepresentation, } from '@aelionsdk/media';
+const SAMPLE_INDEX_CACHE_VERSION = 'aelion-sample-index-v1';
+function positiveSafeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new RangeError(`${name} must be a positive safe integer`);
+    }
+    return value;
+}
+function nonNegativeSafeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function assertIdentifier(value, name) {
+    if (value.trim().length === 0 || value.length > 512) {
+        throw new TypeError(`${name} must be a non-empty string of at most 512 characters`);
+    }
+}
+function assertOptionalDimension(value, name) {
+    if (value !== undefined)
+        positiveSafeInteger(value, name);
+}
+function assertOptionalTime(value, name, allowZero) {
+    if (value === undefined)
+        return;
+    if (!Number.isSafeInteger(value) || value < 0 || (!allowZero && value === 0)) {
+        throw new RangeError(`${name} must be ${allowZero ? 'a non-negative' : 'a positive'} safe integer`);
+    }
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException('Operation aborted', 'AbortError');
+}
+function asError(value, fallback) {
+    return value instanceof Error ? value : new Error(fallback, { cause: value });
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function serializeSampleIndex(index) {
+    return new TextEncoder().encode(JSON.stringify(index, (_key, value) => value instanceof Uint8Array ? { __aelionBytes: [...value] } : value));
+}
+function reviveBytes(value) {
+    if (Array.isArray(value))
+        return value.map(entry => reviveBytes(entry));
+    if (!isRecord(value))
+        return value;
+    if (Array.isArray(value.__aelionBytes) &&
+        value.__aelionBytes.every(byte => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+        return Uint8Array.from(value.__aelionBytes);
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, reviveBytes(entry)]));
+}
+function deserializeSampleIndex(bytes) {
+    let value;
+    try {
+        const parsed = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        value = reviveBytes(parsed);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(value) ||
+        value.schemaVersion !== '1.0.0' ||
+        typeof value.durationUs !== 'number' ||
+        !Array.isArray(value.tracks) ||
+        !isRecord(value.samples) ||
+        !isRecord(value.presentationOrder) ||
+        !Array.isArray(value.diagnostics)) {
+        return undefined;
+    }
+    return value;
+}
+function awaitWithSignal(promise, signal) {
+    if (signal === undefined)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortReason(signal));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortReason(signal));
+        signal.addEventListener('abort', onAbort, { once: true });
+        void promise.then(value => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(asError(error, 'Media operation failed'));
+        });
+    });
+}
+/**
+ * Range-backed media provider for File/Blob, URL and OPFS sources.
+ *
+ * It keeps whole media out of JavaScript memory, reuses content-addressed
+ * SampleIndexes, chooses preview proxies, and bounds decoder work across a page.
+ */
+export class ProductionMediaProvider {
+    #assets = new Map();
+    #residentIndexes = new Map();
+    #decodeSessions = new Map();
+    #residentImages = new Map();
+    #indexOperations = new Map();
+    #cache;
+    #governor;
+    #ownsGovernor;
+    #maxCachedIndexes;
+    #maxCachedIndexBytes;
+    #maxDecodeSessions;
+    #maxCachedVideoFramesPerSession;
+    #maxCachedVideoBytesPerSession;
+    #maxSequentialDecodeGapUs;
+    #maxCachedImages;
+    #maxCachedImageBytes;
+    #maxImageDecodeBytes;
+    #maxConcurrentOperations;
+    #maxPendingOperations;
+    #waiters = [];
+    #lifecycle = new AbortController();
+    #cachedIndexBytes = 0;
+    #cachedImageBytes = 0;
+    #imageCacheHits = 0;
+    #imageCacheMisses = 0;
+    #clock = 0;
+    #activeOperations = 0;
+    #operationSequence = 0;
+    #generation = 0;
+    #disposed = false;
+    constructor(options = {}) {
+        this.#maxCachedIndexes = positiveSafeInteger(options.maxCachedIndexes ?? 8, 'maxCachedIndexes');
+        this.#maxCachedIndexBytes = positiveSafeInteger(options.maxCachedIndexBytes ?? 64 * 1_024 * 1_024, 'maxCachedIndexBytes');
+        this.#maxConcurrentOperations = positiveSafeInteger(options.maxConcurrentOperations ?? 4, 'maxConcurrentOperations');
+        this.#maxPendingOperations = nonNegativeSafeInteger(options.maxPendingOperations ?? 64, 'maxPendingOperations');
+        this.#maxDecodeSessions = positiveSafeInteger(options.maxDecodeSessions ?? this.#maxConcurrentOperations, 'maxDecodeSessions');
+        this.#maxCachedVideoFramesPerSession = positiveSafeInteger(options.maxCachedVideoFramesPerSession ?? 24, 'maxCachedVideoFramesPerSession');
+        this.#maxCachedVideoBytesPerSession = positiveSafeInteger(options.maxCachedVideoBytesPerSession ?? 96 * 1_024 * 1_024, 'maxCachedVideoBytesPerSession');
+        this.#maxSequentialDecodeGapUs = positiveSafeInteger(options.maxSequentialDecodeGapUs ?? 3_000_000, 'maxSequentialDecodeGapUs');
+        this.#maxCachedImages = positiveSafeInteger(options.maxCachedImages ?? 16, 'maxCachedImages');
+        this.#maxCachedImageBytes = positiveSafeInteger(options.maxCachedImageBytes ?? 256 * 1_024 * 1_024, 'maxCachedImageBytes');
+        this.#maxImageDecodeBytes = positiveSafeInteger(options.maxImageDecodeBytes ?? 64 * 1_024 * 1_024, 'maxImageDecodeBytes');
+        this.#cache = options.cache ?? new MemoryCacheStore(this.#maxCachedIndexBytes);
+        this.#ownsGovernor = options.governor === undefined;
+        this.#governor =
+            options.governor ??
+                new PageMediaResourceGovernor({
+                    decoderSlots: this.#maxConcurrentOperations,
+                    gpuBytes: 1,
+                    cacheBytes: this.#maxCachedIndexBytes,
+                }, Math.max(1, this.#maxPendingOperations));
+    }
+    registerReader(assetId, reader, options = {}) {
+        this.#assertActive();
+        assertIdentifier(assetId, 'assetId');
+        assertIdentifier(reader.id, 'RangeReader id');
+        const role = options.role ?? 'original';
+        const id = options.id ?? `${assetId}:${role}`;
+        assertIdentifier(id, 'representation id');
+        assertOptionalTime(options.durationUs, 'durationUs', false);
+        assertOptionalTime(options.sourceStartUs, 'sourceStartUs', true);
+        assertOptionalDimension(options.width, 'width');
+        assertOptionalDimension(options.height, 'height');
+        if (options.mimeType !== undefined && options.mimeType.trim().length === 0) {
+            throw new TypeError('mimeType must be a non-empty string');
+        }
+        if (options.contentHash !== undefined && !/^[0-9a-f]{64}$/u.test(options.contentHash)) {
+            throw new TypeError('contentHash must be a lowercase SHA-256 value');
+        }
+        let asset = this.#assets.get(assetId);
+        if (asset === undefined) {
+            asset = { representations: new Map() };
+            this.#assets.set(assetId, asset);
+        }
+        if (role === 'original') {
+            for (const [existingId, existing] of asset.representations) {
+                if (existing.role === 'original' && existingId !== id) {
+                    asset.representations.delete(existingId);
+                    this.#dropResidentIndex(this.#indexKey(assetId, existingId));
+                    this.#dropDecodeSessions(assetId, existingId);
+                    this.#dropResidentImage(this.#indexKey(assetId, existingId));
+                }
+            }
+        }
+        asset.representations.set(id, {
+            id,
+            role,
+            reader,
+            kind: options.kind ?? 'media',
+            ...(options.mimeType === undefined ? {} : { mimeType: options.mimeType }),
+            ...(options.durationUs === undefined ? {} : { durationUs: options.durationUs }),
+            ...(options.width === undefined ? {} : { width: options.width }),
+            ...(options.height === undefined ? {} : { height: options.height }),
+            ...(options.contentHash === undefined ? {} : { contentHash: options.contentHash }),
+            ...(options.sourceStartUs === undefined ? {} : { sourceStartUs: options.sourceStartUs }),
+        });
+        this.#generation += 1;
+        this.#dropResidentIndex(this.#indexKey(assetId, id));
+        this.#dropDecodeSessions(assetId, id);
+        this.#dropResidentImage(this.#indexKey(assetId, id));
+    }
+    registerBlob(assetId, blob, options = {}) {
+        const role = options.role ?? 'original';
+        const id = options.id ?? `${assetId}:${role}`;
+        this.registerReader(assetId, new BlobRangeReader(id, blob), {
+            ...options,
+            id,
+            role,
+            kind: options.kind ?? (blob.type.startsWith('image/') ? 'image' : 'media'),
+            ...(options.mimeType === undefined && blob.type.length > 0 ? { mimeType: blob.type } : {}),
+        });
+    }
+    registerFile(assetId, file, options = {}) {
+        this.registerBlob(assetId, file, options);
+    }
+    registerImageBlob(assetId, blob, options = {}) {
+        this.registerBlob(assetId, blob, {
+            ...options,
+            kind: 'image',
+            ...(options.mimeType === undefined && blob.type.length > 0 ? { mimeType: blob.type } : {}),
+        });
+    }
+    registerImageFile(assetId, file, options = {}) {
+        this.registerImageBlob(assetId, file, options);
+    }
+    registerUrl(assetId, url, options = {}) {
+        const role = options.role ?? 'original';
+        const id = options.id ?? `${assetId}:${role}`;
+        const readerOptions = {
+            ...(options.headers === undefined ? {} : { headers: options.headers }),
+            ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+        };
+        this.registerReader(assetId, new FetchRangeReader(id, url, readerOptions), {
+            ...options,
+            id,
+            role,
+        });
+    }
+    async registerOpfs(assetId, path, options = {}) {
+        this.#assertActive();
+        const navigatorValue = Reflect.get(globalThis, 'navigator');
+        const storage = isRecord(navigatorValue) ? navigatorValue.storage : undefined;
+        const getDirectory = isRecord(storage) ? storage.getDirectory : undefined;
+        if (typeof getDirectory !== 'function') {
+            throw new Error('Origin Private File System is unavailable');
+        }
+        const parts = path.split('/');
+        if (parts.length === 0 ||
+            parts.some(part => part.length === 0 || part === '.' || part === '..')) {
+            throw new TypeError('OPFS path must be a relative file path without empty or dot segments');
+        }
+        const fileName = parts.pop();
+        if (fileName === undefined)
+            throw new TypeError('OPFS path must name a file');
+        let directory = await Reflect.apply(getDirectory, storage, []);
+        for (const part of parts)
+            directory = await directory.getDirectoryHandle(part);
+        const handle = await directory.getFileHandle(fileName);
+        const file = await handle.getFile();
+        this.registerFile(assetId, file, options);
+    }
+    unregister(assetId) {
+        this.#assertActive();
+        const removed = this.#assets.delete(assetId);
+        if (!removed)
+            return false;
+        this.#generation += 1;
+        for (const key of [...this.#residentIndexes.keys()]) {
+            if (key.startsWith(`${assetId}\u0000`))
+                this.#dropResidentIndex(key);
+        }
+        this.#dropDecodeSessions(assetId);
+        for (const key of [...this.#residentImages.keys()]) {
+            if (key.startsWith(`${assetId}\u0000`))
+                this.#dropResidentImage(key);
+        }
+        return true;
+    }
+    representationFor(assetId, request = {}) {
+        const selected = this.#select(assetId, request);
+        return {
+            assetId,
+            representationId: selected.representation.id,
+            role: selected.representation.role,
+            usedProxy: selected.usedProxy,
+            diagnostics: selected.diagnostics,
+        };
+    }
+    async probe(assetId, options = {}) {
+        const selected = this.#select(assetId, options);
+        const index = await this.#sampleIndex(assetId, selected.representation, options.signal);
+        return {
+            assetId,
+            representationId: selected.representation.id,
+            role: selected.representation.role,
+            usedProxy: selected.usedProxy,
+            diagnostics: selected.diagnostics,
+            index,
+        };
+    }
+    async frameAt(assetId, streamIndex, sourceTimeUs, signal, request) {
+        this.#assertActive();
+        const selected = this.#select(assetId, request ?? { purpose: 'export' });
+        if (selected.representation.kind === 'image') {
+            if (streamIndex !== 0)
+                throw new RangeError('Still images only expose stream index 0');
+            return this.#run(signal, operationSignal => this.#imageFrame(assetId, selected.representation, operationSignal));
+        }
+        const index = await this.#sampleIndex(assetId, selected.representation, signal);
+        const presentationTimeUs = proxyPresentationTimeUs(sourceTimeUs, {
+            id: selected.representation.id,
+            role: selected.representation.role,
+            locator: selected.representation.reader.id,
+            ...(selected.representation.durationUs === undefined
+                ? {}
+                : { durationUs: selected.representation.durationUs }),
+            ...(selected.representation.sourceStartUs === undefined
+                ? {}
+                : { sourceStartUs: selected.representation.sourceStartUs }),
+        });
+        return this.#run(signal, async (operationSignal) => {
+            const lease = await this.#governor.acquire({
+                ownerId: `aelion-media:${++this.#operationSequence}:${assetId}`,
+                priority: request?.purpose === 'preview' ? 'preview' : 'export',
+                decoderSlots: 1,
+                gpuBytes: 0,
+                cacheBytes: 0,
+            }, operationSignal);
+            try {
+                const resident = this.#acquireDecodeSession(assetId, selected.representation, streamIndex, index);
+                try {
+                    const result = resident === undefined
+                        ? await decodeVideoFrameAtFromReader(selected.representation.reader, presentationTimeUs, {
+                            sampleIndex: index,
+                            streamIndex,
+                            signal: operationSignal,
+                            maxDecodeQueueSize: 8,
+                        })
+                        : await resident.session.frameAt(presentationTimeUs, operationSignal);
+                    try {
+                        throwIfAborted(operationSignal, 'production media video decode');
+                        return result.frame.clone();
+                    }
+                    finally {
+                        result.close();
+                    }
+                }
+                finally {
+                    if (resident !== undefined) {
+                        resident.active -= 1;
+                        resident.access = ++this.#clock;
+                    }
+                }
+            }
+            finally {
+                await lease.dispose();
+            }
+        });
+    }
+    async pcmRange(assetId, streamIndex, startUs, durationUs, signal) {
+        this.#assertActive();
+        const selected = this.#select(assetId, { purpose: 'export' });
+        return this.#run(signal, async (operationSignal) => {
+            const lease = await this.#governor.acquire({
+                ownerId: `aelion-media:${++this.#operationSequence}:${assetId}:audio`,
+                priority: 'preview',
+                decoderSlots: 1,
+                gpuBytes: 0,
+                cacheBytes: 0,
+            }, operationSignal);
+            try {
+                return await decodeAudioPcmRangeFromReader(selected.representation.reader, startUs, durationUs, { streamIndex, signal: operationSignal });
+            }
+            finally {
+                await lease.dispose();
+            }
+        });
+    }
+    clear() {
+        this.#assertActive();
+        this.#generation += 1;
+        this.#residentIndexes.clear();
+        this.#cachedIndexBytes = 0;
+        for (const resident of this.#decodeSessions.values())
+            resident.session.dispose();
+        this.#decodeSessions.clear();
+        for (const resident of this.#residentImages.values())
+            resident.frame.close();
+        this.#residentImages.clear();
+        this.#cachedImageBytes = 0;
+    }
+    registerImageUrl(assetId, url, options = {}) {
+        this.registerUrl(assetId, url, { ...options, kind: 'image' });
+    }
+    snapshot() {
+        const decodeSnapshots = [...this.#decodeSessions.values()].map(value => value.session.snapshot());
+        return {
+            assets: this.#assets.size,
+            representations: [...this.#assets.values()].reduce((total, asset) => total + asset.representations.size, 0),
+            cachedIndexes: this.#residentIndexes.size,
+            cachedIndexBytes: this.#cachedIndexBytes,
+            maxCachedIndexes: this.#maxCachedIndexes,
+            maxCachedIndexBytes: this.#maxCachedIndexBytes,
+            decodeSessions: this.#decodeSessions.size,
+            activeDecodeSessions: [...this.#decodeSessions.values()].filter(value => value.active > 0)
+                .length,
+            maxDecodeSessions: this.#maxDecodeSessions,
+            cachedVideoFrames: decodeSnapshots.reduce((total, value) => total + value.cachedFrames, 0),
+            cachedVideoBytes: decodeSnapshots.reduce((total, value) => total + value.cachedBytes, 0),
+            maxCachedVideoFramesPerSession: this.#maxCachedVideoFramesPerSession,
+            maxCachedVideoBytesPerSession: this.#maxCachedVideoBytesPerSession,
+            maxSequentialDecodeGapUs: this.#maxSequentialDecodeGapUs,
+            decodeCacheHits: decodeSnapshots.reduce((total, value) => total + value.cacheHits, 0),
+            decodeCacheMisses: decodeSnapshots.reduce((total, value) => total + value.cacheMisses, 0),
+            decodeSeeks: decodeSnapshots.reduce((total, value) => total + value.seeks, 0),
+            sequentialDecodedFrames: decodeSnapshots.reduce((total, value) => total + value.sequentialFrames, 0),
+            cachedImages: this.#residentImages.size,
+            cachedImageBytes: this.#cachedImageBytes,
+            maxCachedImages: this.#maxCachedImages,
+            maxCachedImageBytes: this.#maxCachedImageBytes,
+            maxImageDecodeBytes: this.#maxImageDecodeBytes,
+            imageCacheHits: this.#imageCacheHits,
+            imageCacheMisses: this.#imageCacheMisses,
+            activeOperations: this.#activeOperations,
+            pendingOperations: this.#waiters.length,
+            maxConcurrentOperations: this.#maxConcurrentOperations,
+            maxPendingOperations: this.#maxPendingOperations,
+            governor: this.#governor.snapshot(),
+            cache: this.#cache.snapshot(),
+            disposed: this.#disposed,
+        };
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#lifecycle.abort(new DOMException('ProductionMediaProvider was disposed', 'AbortError'));
+        for (const waiter of this.#waiters.splice(0)) {
+            waiter.signal?.removeEventListener('abort', waiter.onAbort);
+            waiter.reject(new ReferenceError('ProductionMediaProvider is disposed'));
+        }
+        this.#assets.clear();
+        this.#residentIndexes.clear();
+        this.#cachedIndexBytes = 0;
+        for (const resident of this.#decodeSessions.values())
+            resident.session.dispose();
+        this.#decodeSessions.clear();
+        for (const resident of this.#residentImages.values())
+            resident.frame.close();
+        this.#residentImages.clear();
+        this.#cachedImageBytes = 0;
+        if (this.#ownsGovernor)
+            this.#governor.dispose();
+    }
+    #select(assetId, request) {
+        this.#assertActive();
+        const asset = this.#assets.get(assetId);
+        if (asset === undefined)
+            throw new ReferenceError(`Unknown media asset: ${assetId}`);
+        const original = [...asset.representations.values()].find(value => value.role === 'original');
+        if (original === undefined)
+            throw new ReferenceError(`Media asset has no original: ${assetId}`);
+        const manifest = {
+            id: assetId,
+            locator: original.reader.id,
+            representations: [...asset.representations.values()].map(value => ({
+                id: value.id,
+                role: value.role,
+                locator: value.reader.id,
+                ...(value.durationUs === undefined ? {} : { durationUs: value.durationUs }),
+                ...(value.width === undefined ? {} : { width: value.width }),
+                ...(value.height === undefined ? {} : { height: value.height }),
+                ...(value.contentHash === undefined ? {} : { contentHash: value.contentHash }),
+                ...(value.sourceStartUs === undefined ? {} : { sourceStartUs: value.sourceStartUs }),
+            })),
+        };
+        const selection = selectAssetRepresentation(manifest, {
+            purpose: request.purpose ?? 'export',
+            ...(request.maxDimension === undefined ? {} : { maxDimension: request.maxDimension }),
+            ...(original.durationUs === undefined ? {} : { sourceDurationUs: original.durationUs }),
+        });
+        const representation = asset.representations.get(selection.representation.id);
+        if (representation === undefined) {
+            throw new Error(`Selected media representation is not registered: ${selection.representation.id}`);
+        }
+        return {
+            representation,
+            usedProxy: selection.usedProxy,
+            diagnostics: selection.diagnostics,
+        };
+    }
+    #sampleIndex(assetId, representation, signal) {
+        throwIfAborted(signal, 'production media sample index');
+        const key = this.#indexKey(assetId, representation.id);
+        const resident = this.#residentIndexes.get(key);
+        if (resident !== undefined) {
+            resident.access = ++this.#clock;
+            return Promise.resolve(resident.index);
+        }
+        const current = this.#indexOperations.get(key);
+        if (current !== undefined)
+            return awaitWithSignal(current, signal);
+        const generation = this.#generation;
+        const operation = this.#run(this.#lifecycle.signal, async (operationSignal) => {
+            const address = this.#cacheAddress(representation);
+            if (address !== undefined) {
+                const cached = await this.#cache.get(address, operationSignal);
+                if (cached !== undefined) {
+                    const restored = deserializeSampleIndex(cached);
+                    if (restored !== undefined) {
+                        this.#rememberIndex(key, restored, cached.byteLength, generation);
+                        this.#hydrateRepresentation(representation, restored, generation);
+                        return restored;
+                    }
+                    await this.#cache.delete(address, operationSignal);
+                }
+            }
+            const index = await createSampleIndexFromReader(representation.reader, {
+                signal: operationSignal,
+            });
+            const serialized = serializeSampleIndex(index);
+            this.#hydrateRepresentation(representation, index, generation);
+            this.#rememberIndex(key, index, serialized.byteLength, generation);
+            if (address !== undefined && serialized.byteLength <= this.#maxCachedIndexBytes) {
+                await this.#cache.put(address, serialized, operationSignal);
+            }
+            return index;
+        });
+        this.#indexOperations.set(key, operation);
+        void operation.finally(() => this.#indexOperations.delete(key)).catch(() => undefined);
+        return awaitWithSignal(operation, signal);
+    }
+    #hydrateRepresentation(representation, index, generation) {
+        if (generation !== this.#generation)
+            return;
+        representation.durationUs ??= index.durationUs;
+        const video = index.tracks.find(track => track.kind === 'video');
+        if (video !== undefined) {
+            representation.width ??= video.codedWidth;
+            representation.height ??= video.codedHeight;
+        }
+    }
+    #rememberIndex(key, index, byteLength, generation) {
+        if (generation !== this.#generation || byteLength > this.#maxCachedIndexBytes)
+            return;
+        this.#dropResidentIndex(key);
+        this.#residentIndexes.set(key, { index, byteLength, access: ++this.#clock });
+        this.#cachedIndexBytes += byteLength;
+        while (this.#residentIndexes.size > this.#maxCachedIndexes ||
+            this.#cachedIndexBytes > this.#maxCachedIndexBytes) {
+            const oldest = [...this.#residentIndexes.entries()].sort((left, right) => left[1].access - right[1].access)[0];
+            if (oldest === undefined)
+                break;
+            this.#dropResidentIndex(oldest[0]);
+        }
+    }
+    #dropResidentIndex(key) {
+        const resident = this.#residentIndexes.get(key);
+        if (resident !== undefined)
+            this.#cachedIndexBytes -= resident.byteLength;
+        this.#residentIndexes.delete(key);
+    }
+    #acquireDecodeSession(assetId, representation, streamIndex, index) {
+        const key = this.#decodeSessionKey(assetId, representation.id, streamIndex);
+        const existing = this.#decodeSessions.get(key);
+        if (existing !== undefined) {
+            existing.active += 1;
+            existing.access = ++this.#clock;
+            return existing;
+        }
+        while (this.#decodeSessions.size >= this.#maxDecodeSessions) {
+            const oldest = [...this.#decodeSessions.entries()]
+                .filter(([, value]) => value.active === 0)
+                .sort((left, right) => left[1].access - right[1].access)[0];
+            if (oldest === undefined)
+                return undefined;
+            oldest[1].session.dispose();
+            this.#decodeSessions.delete(oldest[0]);
+        }
+        const resident = {
+            session: createVideoFrameDecodeSessionFromReader(representation.reader, index, {
+                streamIndex,
+                maxCachedFrames: this.#maxCachedVideoFramesPerSession,
+                maxCachedBytes: this.#maxCachedVideoBytesPerSession,
+                maxSequentialGapUs: this.#maxSequentialDecodeGapUs,
+            }),
+            active: 1,
+            access: ++this.#clock,
+        };
+        this.#decodeSessions.set(key, resident);
+        return resident;
+    }
+    #dropDecodeSessions(assetId, representationId) {
+        const prefix = representationId === undefined
+            ? `${assetId}\u0000`
+            : `${assetId}\u0000${representationId}\u0000`;
+        for (const [key, resident] of [...this.#decodeSessions]) {
+            if (!key.startsWith(prefix))
+                continue;
+            resident.session.dispose();
+            this.#decodeSessions.delete(key);
+        }
+    }
+    async #imageFrame(assetId, representation, signal) {
+        const key = this.#indexKey(assetId, representation.id);
+        const resident = this.#residentImages.get(key);
+        if (resident !== undefined) {
+            resident.access = ++this.#clock;
+            this.#imageCacheHits += 1;
+            return resident.frame.clone();
+        }
+        this.#imageCacheMisses += 1;
+        const generation = this.#generation;
+        const decoded = await decodeStillImageFromReader(representation.reader, {
+            maxBytes: this.#maxImageDecodeBytes,
+            ...(representation.mimeType === undefined ? {} : { mimeType: representation.mimeType }),
+            signal,
+        });
+        const byteLength = (() => {
+            try {
+                return decoded.frame.allocationSize();
+            }
+            catch {
+                return decoded.width * decoded.height * 4;
+            }
+        })();
+        const value = {
+            frame: decoded.frame,
+            byteLength,
+            access: ++this.#clock,
+        };
+        if (generation === this.#generation && byteLength <= this.#maxCachedImageBytes) {
+            this.#rememberImage(key, value);
+        }
+        try {
+            return value.frame.clone();
+        }
+        finally {
+            if (this.#residentImages.get(key) !== value)
+                value.frame.close();
+        }
+    }
+    #rememberImage(key, image) {
+        this.#dropResidentImage(key);
+        this.#residentImages.set(key, image);
+        this.#cachedImageBytes += image.byteLength;
+        while (this.#residentImages.size > this.#maxCachedImages ||
+            this.#cachedImageBytes > this.#maxCachedImageBytes) {
+            const oldest = [...this.#residentImages.entries()].sort((left, right) => left[1].access - right[1].access)[0];
+            if (oldest === undefined)
+                break;
+            this.#dropResidentImage(oldest[0]);
+        }
+    }
+    #dropResidentImage(key) {
+        const resident = this.#residentImages.get(key);
+        if (resident === undefined)
+            return;
+        this.#residentImages.delete(key);
+        this.#cachedImageBytes -= resident.byteLength;
+        resident.frame.close();
+    }
+    #cacheAddress(representation) {
+        return representation.contentHash === undefined
+            ? undefined
+            : {
+                namespace: 'sample-index',
+                contentHash: representation.contentHash,
+                version: SAMPLE_INDEX_CACHE_VERSION,
+                variant: representation.id,
+            };
+    }
+    #indexKey(assetId, representationId) {
+        return `${assetId}\u0000${representationId}`;
+    }
+    #decodeSessionKey(assetId, representationId, streamIndex) {
+        return `${assetId}\u0000${representationId}\u0000${streamIndex.toString()}`;
+    }
+    async #run(signal, operation) {
+        this.#assertActive();
+        const release = await this.#acquireOperation(signal);
+        const controller = new AbortController();
+        const signals = signal === undefined ? [this.#lifecycle.signal] : [this.#lifecycle.signal, signal];
+        const listeners = signals.map(source => {
+            const abort = () => controller.abort(abortReason(source));
+            source.addEventListener('abort', abort, { once: true });
+            if (source.aborted)
+                abort();
+            return { source, abort };
+        });
+        try {
+            throwIfAborted(controller.signal, 'production media operation');
+            return await operation(controller.signal);
+        }
+        finally {
+            for (const listener of listeners) {
+                listener.source.removeEventListener('abort', listener.abort);
+            }
+            release();
+        }
+    }
+    #acquireOperation(signal) {
+        if (signal?.aborted === true)
+            return Promise.reject(abortReason(signal));
+        if (this.#activeOperations < this.#maxConcurrentOperations && this.#waiters.length === 0) {
+            this.#activeOperations += 1;
+            return Promise.resolve(this.#releaseOperation());
+        }
+        if (this.#waiters.length >= this.#maxPendingOperations) {
+            return Promise.reject(new RangeError('MEDIA_RESOURCE_QUEUE_FULL'));
+        }
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                const index = this.#waiters.indexOf(waiter);
+                if (index < 0)
+                    return;
+                this.#waiters.splice(index, 1);
+                reject(signal === undefined ? new Error('Operation aborted') : abortReason(signal));
+            };
+            const waiter = {
+                resolve,
+                reject,
+                ...(signal === undefined ? {} : { signal }),
+                onAbort,
+            };
+            this.#waiters.push(waiter);
+            signal?.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    #releaseOperation() {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.#activeOperations -= 1;
+            const waiter = this.#waiters.shift();
+            if (waiter === undefined)
+                return;
+            waiter.signal?.removeEventListener('abort', waiter.onAbort);
+            this.#activeOperations += 1;
+            waiter.resolve(this.#releaseOperation());
+        };
+    }
+    #assertActive() {
+        if (this.#disposed)
+            throw new ReferenceError('ProductionMediaProvider is disposed');
+    }
+}