supervision 0.2.0-next.0 → 0.2.0-next.1

package/dist/index.js

@@ -1,5 +1,7 @@
-import { copySortedDetectionFrames, detectionFrameOverlapsRange, projectDetectionFrameForTracking, createSortTracker, createOCSortTracker, createCBIoUTracker, createByteTrackTracker, MediaErrorKind, includeDefined, MediaSourceStatus, MediaRendererPlaybackState, MediaRendererFit, createDefaultAnnotationPresentation, createProjectedDetectionFrameSource, createArrayDetectionFrameSource, createBufferedDetectionTimeline, resolveAnnotationRendererPresentation, PlaybackGateReach, createIdleDetectionBufferState, MediaInteractionMode, decodeCompressedRleMask, createIdMaskFrame, encodeBinaryMask, rasterizePolygonToMask, canReuseMaskStyleArtifacts, getBufferedDetectionTimelineFrameSnapshot, MAX_ID_MASK_PALETTE_ENTRIES, StrokeAlignment, BaseBoxStyle, centerRectToTopLeftRect, BoxShape, BaseFocusStyle, extractDetectionMaskRectRuns, AnnotationGestureStateKind, AnnotationHandleKind, getDetectionRect, DetectionPickTarget, createDetectionPickKey, rebaseDetectionPickToFrame, pickDetectionAtPoint, followDetectionPickAcrossFrames, haveSameDetectionPickIdentities, pickAnnotationHandle, getAnnotationHandles, LabelPlacement, BasePolygonStyle, BasePolylineStyle, BaseKeypointStyle, ShapeInstructionKind, sampleEllipseArc, resolveEllipseSegmentCount, KeypointMarkerShape, MarkerSizeSpace, MarkerShape, resolveMarkerGeometry, BaseInteractionStyle, DetectionInteractionState, DetectionBufferStatus, MAX_ID_MASK_STROKE_WIDTH, resolveMaskStyleOpacity, pickDetectionByMaskId, BoxStrokeAlignment, RegionRendererMediaEffectKind, RegionRendererSourceKind, RegionRendererCoverageKind, RegionRendererSizeSpace, resolveStyleValue, resolveAnnotationStyleState, lightenColor, resolveAnnotationRendererStyleFields, annotationRendererKinds, createViewportController, MediaSessionMode, DetectionFrameRetentionMode, createMemoryColdDetectionFrameStore, createWritableDetectionFrameSource, createCompositeDetectionFrameSource, MediaSessionActivityStatus, MediaSessionActivityKind, MediaSessionStatus, createSourceAwarePresentation, projectDetectionFrames, DetectionFrameSelectionMode } from 'supervision-js-core';
+import { copySortedDetectionFrames, detectionFrameOverlapsRange, projectDetectionFrameForTracking, createSortTracker, createOCSortTracker, createCBIoUTracker, createByteTrackTracker, MediaErrorKind, includeDefined, MediaSourceStatus, MediaRendererPlaybackState, MediaRendererFit, createDefaultAnnotationPresentation, createProjectedDetectionFrameSource, createArrayDetectionFrameSource, createBufferedDetectionTimeline, resolveAnnotationRendererPresentation, PlaybackGateReach, createIdleDetectionBufferState, MediaInteractionMode, decodeCompressedRleMask, createIdMaskFrame, encodeBinaryMask, rasterizePolygonToMask, resolveIdMaskPaletteId, decodeCompressedRleCounts, canReuseMaskStyleArtifacts, getBufferedDetectionTimelineFrameSnapshot, MAX_ID_MASK_PALETTE_ENTRIES, StrokeAlignment, BaseBoxStyle, centerRectToTopLeftRect, BoxShape, BaseFocusStyle, extractDetectionMaskRectRuns, AnnotationGestureStateKind, AnnotationHandleKind, getDetectionRect, DetectionPickTarget, createDetectionPickKey, rebaseDetectionPickToFrame, pickDetectionAtPoint, followDetectionPickAcrossFrames, haveSameDetectionPickIdentities, pickAnnotationHandle, getAnnotationHandles, LabelPlacement, BasePolygonStyle, BasePolylineStyle, BaseKeypointStyle, ShapeInstructionKind, sampleEllipseArc, resolveEllipseSegmentCount, KeypointMarkerShape, MarkerSizeSpace, MarkerShape, resolveMarkerGeometry, BaseInteractionStyle, DetectionInteractionState, writeIdMaskPaletteEntry, resolveIdMaskStrokeTexels, MAX_ID_MASK_STROKE_WIDTH, DetectionBufferStatus, resolveMaskStyleOpacity, pickDetectionByMaskId, BoxStrokeAlignment, RegionRendererMediaEffectKind, RegionRendererSourceKind, RegionRendererCoverageKind, RegionRendererSizeSpace, resolveStyleValue, resolveAnnotationStyleState, lightenColor, resolveAnnotationRendererStyleFields, annotationRendererKinds, createViewportController, MediaSessionMode, DetectionFrameRetentionMode, createMemoryColdDetectionFrameStore, createWritableDetectionFrameSource, createCompositeDetectionFrameSource, MediaSessionActivityStatus, MediaSessionActivityKind, MediaSessionStatus, createSourceAwarePresentation, projectDetectionFrames, DetectionFrameSelectionMode } from 'supervision-js-core';
 export { BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MarkerShape, MarkerSizeSpace, MaskRenderMode, MediaErrorKind, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, PlaybackGateReach, RegionRendererComposeMode, RegionRendererCoverageKind, RegionRendererMediaEffectKind, RegionRendererRegionKind, RegionRendererSizeSpace, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, TrackingGeometry, annotationRendererKinds, annotationRenderers, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createMemoryColdDetectionFrameStore, createOCSortTracker, createProjectedDetectionFrameSource, createSortTracker, createWritableDetectionFrameSource, detectionPostProcessors, normalizeDetectionClassName, pickDetectionAtPoint, projectDetectionFrame, projectDetectionFrameForTracking, projectDetectionFrames, resolveDetectionClassColorStyle } from 'supervision-js-core';
+import { M as MediaSourceError, t as toMediaSourceError, r as resolveDisplayPixelRatio } from './video-engine-media-source-CUXnOJOV.js';
+export { c as createWebVideoEngineMediaRendererSource, g as getMediaErrorKind, i as isMediaSourceError, o as openWebVideoEngineMediaSource } from './video-engine-media-source-CUXnOJOV.js';
 
 const DEFAULT_DATABASE_NAME = "supervision-js-detection-frames";
 const DEFAULT_CHUNK_DURATION_SECONDS = 1;
@@ -495,7 +497,7 @@ function getDetectionFrameDedupeKey(frame) {
         : `index:${frame.frameIndex}`;
 }
 
-const EMBEDDED_TRACKING_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /**\n     * Creates one stateful SORT tracker for a single ordered media sequence.\n     *\n     * Defaults, lifecycle semantics, and observation-only output mirror\n     * roboflow/trackers SORT. Motion predictions remain internal to association.\n     */\n    function createSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.25;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                const predicted = tracks.map((track) => track.predict(frameStep, frameRate));\n                const { matches, unmatchedDetections } = associateDetectionsToTracks(detections, predicted, minimumIouThreshold);\n                const trackerIds = new Map();\n                for (const match of matches) {\n                    const track = tracks[match.trackIndex];\n                    const detection = detections[match.detectionIndex];\n                    track.update(detection);\n                    if (track.trackerId === undefined &&\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        track.trackerId = nextTrackerId;\n                        nextTrackerId += 1;\n                    }\n                    if (track.trackerId !== undefined) {\n                        trackerIds.set(detection.detectionIndex, track.trackerId);\n                    }\n                }\n                for (const detectionIndex of unmatchedDetections) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection));\n                    }\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = trackerIds.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n    }\n    class KalmanBoxTrack {\n        consecutiveUpdates;\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        state;\n        covariance = identity(8);\n        constructor(detection, consecutiveUpdates = false) {\n            this.consecutiveUpdates = consecutiveUpdates;\n            this.state = [...rectToXyxy(detection.rect), 0, 0, 0, 0].map((value) => [\n                value,\n            ]);\n        }\n        predict(frameStep, frameRate) {\n            if (this.consecutiveUpdates && this.timeSinceUpdate > 0) {\n                this.successfulUpdates = 0;\n            }\n            const transition = identity(8);\n            for (let index = 0; index < 4; index += 1) {\n                transition[index][index + 4] = frameStep;\n            }\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), createProcessNoise(frameStep, frameRate));\n            // Python SORT counts update calls for the fixed-rate lost-track budget.\n            this.timeSinceUpdate += 1;\n            return stateToRect(this.state);\n        }\n        update(detection) {\n            const measurement = rectToXyxy(detection.rect).map((value) => [value]);\n            const observation = [\n                [1, 0, 0, 0, 0, 0, 0, 0],\n                [0, 1, 0, 0, 0, 0, 0, 0],\n                [0, 0, 1, 0, 0, 0, 0, 0],\n                [0, 0, 0, 1, 0, 0, 0, 0],\n            ];\n            const measurementNoise = scale(identity(4), 0.1);\n            const innovation = subtract(measurement, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(8), multiply(gain, observation));\n            // Joseph form matches the Python implementation and is more stable.\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, measurementNoise), transpose(gain)));\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getStateRect() {\n            return stateToRect(this.state);\n        }\n    }\n    function associateDetectionsToTracks(detections, predicted, minimumIouThreshold) {\n        if (predicted.length === 0 || detections.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetections: detections.map((_, index) => index),\n            };\n        }\n        // Python SORT associates all detections class-agnostically using standard IoU.\n        const scores = predicted.map((rect) => detections.map((detection) => intersectionOverUnion(rect, detection.rect)));\n        const candidateMatches = maximizeAssignment(scores);\n        const matches = [];\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of candidateMatches) {\n            if (scores[trackIndex][detectionIndex] < minimumIouThreshold)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetections: detections.flatMap((_, index) => matchedDetections.has(index) ? [] : [index]),\n        };\n    }\n    /** Hungarian assignment for a rectangular score matrix. */\n    function maximizeAssignment(scores) {\n        if (scores.length === 0 || scores[0]?.length === 0) {\n            return [];\n        }\n        const rowCount = scores.length;\n        const columnCount = scores[0].length;\n        const transposed = rowCount > columnCount;\n        const costs = transposed\n            ? Array.from({ length: columnCount }, (_, row) => Array.from({ length: rowCount }, (_, column) => 1 - scores[column][row]))\n            : scores.map((row) => row.map((score) => 1 - score));\n        const rows = costs.length;\n        const columns = costs[0].length;\n        const u = new Array(rows + 1).fill(0);\n        const v = new Array(columns + 1).fill(0);\n        const p = new Array(columns + 1).fill(0);\n        const way = new Array(columns + 1).fill(0);\n        for (let row = 1; row <= rows; row += 1) {\n            p[0] = row;\n            let column0 = 0;\n            const minValue = new Array(columns + 1).fill(Number.POSITIVE_INFINITY);\n            const used = new Array(columns + 1).fill(false);\n            do {\n                used[column0] = true;\n                const row0 = p[column0];\n                let delta = Number.POSITIVE_INFINITY;\n                let column1 = 0;\n                for (let column = 1; column <= columns; column += 1) {\n                    if (used[column])\n                        continue;\n                    const current = costs[row0 - 1][column - 1] - u[row0] - v[column];\n                    if (current < minValue[column]) {\n                        minValue[column] = current;\n                        way[column] = column0;\n                    }\n                    if (minValue[column] < delta) {\n                        delta = minValue[column];\n                        column1 = column;\n                    }\n                }\n                for (let column = 0; column <= columns; column += 1) {\n                    if (used[column]) {\n                        u[p[column]] += delta;\n                        v[column] -= delta;\n                    }\n                    else {\n                        minValue[column] -= delta;\n                    }\n                }\n                column0 = column1;\n            } while (p[column0] !== 0);\n            do {\n                const column1 = way[column0];\n                p[column0] = p[column1];\n                column0 = column1;\n            } while (column0 !== 0);\n        }\n        const assignments = [];\n        for (let column = 1; column <= columns; column += 1) {\n            if (p[column] === 0)\n                continue;\n            const row = p[column] - 1;\n            assignments.push(transposed ? [column - 1, row] : [row, column - 1]);\n        }\n        return assignments;\n    }\n    function rectToXyxy(rect) {\n        return [\n            rect.x - rect.width / 2,\n            rect.y - rect.height / 2,\n            rect.x + rect.width / 2,\n            rect.y + rect.height / 2,\n        ];\n    }\n    function stateToRect(state) {\n        // The Python XYXY estimator intentionally leaves corner velocities\n        // unconstrained. Normalize only at the browser Rect boundary so a crossing\n        // prediction cannot violate the positive-width/height storage contract.\n        const x1 = Math.min(state[0][0], state[2][0]);\n        const y1 = Math.min(state[1][0], state[3][0]);\n        const x2 = Math.max(state[0][0], state[2][0]);\n        const y2 = Math.max(state[1][0], state[3][0]);\n        return {\n            height: Math.max(Number.EPSILON, y2 - y1),\n            width: Math.max(Number.EPSILON, x2 - x1),\n            x: (x1 + x2) / 2,\n            y: (y1 + y2) / 2,\n        };\n    }\n    function createProcessNoise(frameStep, frameRate) {\n        if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n            return scale(identity(8), 0.01);\n        }\n        const result = Array.from({ length: 8 }, () => new Array(8).fill(0));\n        const dt2 = frameStep * frameStep;\n        const dt3 = dt2 * frameStep;\n        const dt4 = dt2 * dt2;\n        for (let index = 0; index < 4; index += 1) {\n            const velocityIndex = index + 4;\n            result[index][index] = (0.01 * dt4) / 4;\n            result[index][velocityIndex] = (0.01 * dt3) / 2;\n            result[velocityIndex][index] = (0.01 * dt3) / 2;\n            result[velocityIndex][velocityIndex] = 0.01 * dt2;\n        }\n        return result;\n    }\n    function intersectionOverUnion(left, right) {\n        const leftX = left.x - left.width / 2;\n        const leftY = left.y - left.height / 2;\n        const rightX = right.x - right.width / 2;\n        const rightY = right.y - right.height / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + left.width, rightX + right.width) -\n            Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + left.height, rightY + right.height) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = left.width * left.height + right.width * right.height - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n    function resolveFrameStep(current, previous) {\n        if (current === undefined || previous === undefined)\n            return 1;\n        return Math.max(1, current - previous);\n    }\n    function normalizePositiveInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 1) {\n            throw new Error(`${label} must be a positive integer.`);\n        }\n        return value;\n    }\n    function normalizeNonNegativeInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 0) {\n            throw new Error(`${label} must be a non-negative integer.`);\n        }\n        return value;\n    }\n    function normalizeUnitInterval$1(value, label) {\n        if (!Number.isFinite(value) || value < 0 || value > 1) {\n            throw new Error(`${label} must be between 0 and 1.`);\n        }\n    }\n    function identity(size) {\n        return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));\n    }\n    function scale(matrix, factor) {\n        return matrix.map((row) => row.map((value) => value * factor));\n    }\n    function transpose(matrix) {\n        return matrix[0].map((_, column) => matrix.map((row) => row[column]));\n    }\n    function add(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value + right[rowIndex][columnIndex]));\n    }\n    function subtract(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value - right[rowIndex][columnIndex]));\n    }\n    function multiply(left, right) {\n        return left.map((row) => right[0].map((_, column) => row.reduce((sum, value, index) => sum + value * right[index][column], 0)));\n    }\n    function inverse(matrix) {\n        const size = matrix.length;\n        const augmented = matrix.map((row, index) => [\n            ...row,\n            ...identity(size)[index],\n        ]);\n        for (let column = 0; column < size; column += 1) {\n            let pivot = column;\n            for (let row = column + 1; row < size; row += 1) {\n                if (Math.abs(augmented[row][column]) >\n                    Math.abs(augmented[pivot][column])) {\n                    pivot = row;\n                }\n            }\n            if (Math.abs(augmented[pivot][column]) < 1e-12) {\n                throw new Error(\"SORT Kalman covariance is singular.\");\n            }\n            [augmented[column], augmented[pivot]] = [\n                augmented[pivot],\n                augmented[column],\n            ];\n            const divisor = augmented[column][column];\n            augmented[column] = augmented[column].map((value) => value / divisor);\n            for (let row = 0; row < size; row += 1) {\n                if (row === column)\n                    continue;\n                const factor = augmented[row][column];\n                augmented[row] = augmented[row].map((value, index) => value - factor * augmented[column][index]);\n            }\n        }\n        return augmented.map((row) => row.slice(size));\n    }\n\n    /**\n     * Creates one stateful ByteTrack tracker for a single ordered media sequence.\n     *\n     * Defaults and two-stage association mirror roboflow/trackers ByteTrack at\n     * source commit 60b21c8a48676784085fbee455559f16b75a7c9a.\n     * Motion predictions remain internal; only observed detections receive IDs.\n     */\n    function createByteTrackTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.1;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    if ((detection.confidence ?? 1) >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const assignments = new Map();\n                const firstStage = associate(tracks, detections, highDetectionIndexes, minimumIouThreshold);\n                for (const match of firstStage.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                const remainingTracks = firstStage.unmatchedTrackIndexes.map((index) => tracks[index]);\n                const secondStage = associate(remainingTracks, detections, lowDetectionIndexes, minimumIouThreshold);\n                for (const match of secondStage.matches) {\n                    updateMatchedTrack(remainingTracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                // Only unmatched high-confidence observations can start a track.\n                for (const detectionIndex of firstStage.unmatchedDetectionIndexes) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection, true));\n                    }\n                }\n                // Confirmation is sticky once an ID has been allocated. An unmatched\n                // unconfirmed track is discarded immediately, as in Python ByteTrack.\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = assignments.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId;\n                nextTrackerId += 1;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function associate(tracks, detections, detectionIndexes, minimumIouThreshold) {\n        if (tracks.length === 0 || detectionIndexes.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetectionIndexes: [...detectionIndexes],\n                unmatchedTrackIndexes: tracks.map((_, index) => index),\n            };\n        }\n        const scores = tracks.map((track) => {\n            const predictedRect = track.getStateRect();\n            return detectionIndexes.map((detectionIndex) => intersectionOverUnion(predictedRect, detections[detectionIndex].rect));\n        });\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, localDetectionIndex] of maximizeAssignment(scores)) {\n            if (scores[trackIndex][localDetectionIndex] < minimumIouThreshold) {\n                continue;\n            }\n            const detectionIndex = detectionIndexes[localDetectionIndex];\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: detectionIndexes.filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: tracks.flatMap((_, index) => matchedTracks.has(index) ? [] : [index]),\n        };\n    }\n\n    function associateTrackingScores(scores, trackCount, detectionCount, minimumScore, acceptanceScores = scores) {\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of maximizeAssignment(scores)) {\n            if (acceptanceScores[trackIndex][detectionIndex] < minimumScore)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: Array.from({ length: detectionCount }, (_, index) => index).filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: Array.from({ length: trackCount }, (_, index) => index).filter((index) => !matchedTracks.has(index)),\n        };\n    }\n    function pairwiseIou(tracks, detections, bufferRatio = 0) {\n        return tracks.map((track) => detections.map((detection) => bufferedIntersectionOverUnion(track, detection, bufferRatio)));\n    }\n    function bufferedIntersectionOverUnion(left, right, bufferRatio) {\n        const leftWidth = left.width * (1 + 2 * bufferRatio);\n        const leftHeight = left.height * (1 + 2 * bufferRatio);\n        const rightWidth = right.width * (1 + 2 * bufferRatio);\n        const rightHeight = right.height * (1 + 2 * bufferRatio);\n        const leftX = left.x - leftWidth / 2;\n        const leftY = left.y - leftHeight / 2;\n        const rightX = right.x - rightWidth / 2;\n        const rightY = right.y - rightHeight / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + leftWidth, rightX + rightWidth) - Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + leftHeight, rightY + rightHeight) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = leftWidth * leftHeight + rightWidth * rightHeight - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n\n    /**\n     * Kalman state estimator shared by the browser C-BIoU and OC-SORT ports.\n     * Its layouts, covariance update, and gap-scaled constant-velocity model\n     * mirror roboflow/trackers at 60b21c8.\n     */\n    class TrackingKalmanEstimator {\n        representation;\n        dimension;\n        measurementDimension = 4;\n        covariance;\n        measurementNoise = identity(4);\n        processNoise;\n        state;\n        baselineProcessNoise;\n        positionIndexes;\n        velocityIndexes;\n        constructor(initialRect, representation) {\n            this.representation = representation;\n            const measurement = rectToMeasurement(initialRect, representation);\n            this.dimension = representation === \"xcycsr\" ? 7 : 8;\n            this.positionIndexes =\n                representation === \"xcycsr\" ? [0, 1, 2] : [0, 1, 2, 3];\n            this.velocityIndexes =\n                representation === \"xcycsr\" ? [4, 5, 6] : [4, 5, 6, 7];\n            this.state = Array.from({ length: this.dimension }, (_, index) => [\n                measurement[index] ?? 0,\n            ]);\n            this.covariance = identity(this.dimension);\n            this.processNoise = identity(this.dimension);\n            this.baselineProcessNoise = identity(this.dimension);\n        }\n        predict(frameStep, frameRate) {\n            if (this.representation === \"xcycsr\" &&\n                this.state[2][0] + frameStep * this.state[6][0] <= 0) {\n                this.state[6][0] = 0;\n            }\n            const transition = identity(this.dimension);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                transition[positionIndex][this.velocityIndexes[index]] = frameStep;\n            });\n            this.processNoise = this.createProcessNoise(frameStep, frameRate);\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), this.processNoise);\n        }\n        update(rect) {\n            this.updateMeasurement(rectToMeasurement(rect, this.representation));\n        }\n        updateMeasurement(measurement) {\n            const observation = Array.from({ length: 4 }, (_, row) => Array.from({ length: this.dimension }, (_, column) => row === column ? 1 : 0));\n            const measurementColumn = measurement.map((value) => [value]);\n            const innovation = subtract(measurementColumn, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), this.measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(this.dimension), multiply(gain, observation));\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, this.measurementNoise), transpose(gain)));\n        }\n        getRect() {\n            return measurementToRect(this.state.slice(0, 4).map((row) => row[0]), this.representation);\n        }\n        setCovariances(options) {\n            if (options.covariance)\n                this.covariance = clone(options.covariance);\n            if (options.measurementNoise) {\n                this.measurementNoise = clone(options.measurementNoise);\n            }\n            if (options.processNoise) {\n                this.processNoise = clone(options.processNoise);\n                this.baselineProcessNoise = clone(options.processNoise);\n            }\n        }\n        snapshot() {\n            return {\n                covariance: clone(this.covariance),\n                measurementNoise: clone(this.measurementNoise),\n                processNoise: clone(this.processNoise),\n                state: clone(this.state),\n            };\n        }\n        restore(snapshot) {\n            this.covariance = clone(snapshot.covariance);\n            this.measurementNoise = clone(snapshot.measurementNoise);\n            this.processNoise = clone(snapshot.processNoise);\n            this.state = clone(snapshot.state);\n        }\n        createProcessNoise(frameStep, frameRate) {\n            if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n                return clone(this.baselineProcessNoise);\n            }\n            const result = Array.from({ length: this.dimension }, () => new Array(this.dimension).fill(0));\n            const dt2 = frameStep * frameStep;\n            const dt3 = dt2 * frameStep;\n            const dt4 = dt2 * dt2;\n            const kinematicIndexes = new Set([\n                ...this.positionIndexes,\n                ...this.velocityIndexes,\n            ]);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                const velocityIndex = this.velocityIndexes[index];\n                const accelerationVariance = this.baselineProcessNoise[velocityIndex][velocityIndex];\n                result[positionIndex][positionIndex] = (accelerationVariance * dt4) / 4;\n                result[positionIndex][velocityIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][positionIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][velocityIndex] = accelerationVariance * dt2;\n            });\n            for (let index = 0; index < this.dimension; index += 1) {\n                if (!kinematicIndexes.has(index)) {\n                    result[index][index] = this.baselineProcessNoise[index][index];\n                }\n            }\n            return result;\n        }\n    }\n    function rectToMeasurement(rect, representation) {\n        if (representation === \"xcycwh\") {\n            return [rect.x, rect.y, rect.width, rect.height];\n        }\n        return [\n            rect.x,\n            rect.y,\n            rect.width * rect.height,\n            rect.width / (rect.height + 1e-6),\n        ];\n    }\n    function measurementToRect(measurement, representation) {\n        const [x, y, third, fourth] = measurement;\n        if (representation === \"xcycwh\") {\n            return {\n                height: Math.max(1e-3, fourth),\n                width: Math.max(1e-3, third),\n                x,\n                y,\n            };\n        }\n        const width = Math.sqrt(third * fourth);\n        const height = width === 0 ? 0 : third / width;\n        return {\n            height: Math.max(Number.EPSILON, height),\n            width: Math.max(Number.EPSILON, width),\n            x,\n            y,\n        };\n    }\n    function diagonal(values) {\n        return values.map((value, row) => values.map((_, column) => (row === column ? value : 0)));\n    }\n    function scaleMatrix(matrix, factor) {\n        return scale(matrix, factor);\n    }\n    function clone(matrix) {\n        return matrix.map((row) => [...row]);\n    }\n\n    const MINIMUM_DETECTION_CONFIDENCE = 0.1;\n    class CBIoUTrack {\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        estimator;\n        constructor(initial) {\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycwh\");\n            this.setInitialNoise(initial.rect.width, initial.rect.height);\n        }\n        predict(frameStep, frameRate) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                processNoise: this.buildProcessNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.predict(frameStep, frameRate);\n            this.clampState();\n            this.timeSinceUpdate += 1;\n        }\n        update(detection) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                measurementNoise: this.buildMeasurementNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.update(detection.rect);\n            this.clampState();\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        setInitialNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            this.estimator.setCovariances({\n                covariance: diagonal([\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                ]),\n                measurementNoise: this.buildMeasurementNoise(width, height),\n                processNoise: this.buildProcessNoise(width, height),\n            });\n        }\n        buildProcessNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            return diagonal([\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n            ]);\n        }\n        buildMeasurementNoise(width, height) {\n            const sigmaMeasurement = 0.05;\n            return diagonal([\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n            ]);\n        }\n        clampState() {\n            this.estimator.state[2][0] = Math.max(this.estimator.state[2][0], 1e-3);\n            this.estimator.state[3][0] = Math.max(this.estimator.state[3][0], 1e-3);\n        }\n    }\n    /** Creates the detection-only C-BIoU implementation from roboflow/trackers. */\n    function createCBIoUTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ?? 0.2;\n        const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ?? 0.5;\n        const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ?? 0.3;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const instantFirstFrameActivation = options.instantFirstFrameActivation ?? true;\n        const bufferRatioFirst = options.bufferRatioFirst ?? 0.3;\n        const bufferRatioSecond = options.bufferRatioSecond ?? 0.5;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThresholdFirstAssociation, \"minimumIouThresholdFirstAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdSecondAssociation, \"minimumIouThresholdSecondAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdUnconfirmedAssociation, \"minimumIouThresholdUnconfirmedAssociation\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        if (!Number.isFinite(bufferRatioFirst) || bufferRatioFirst < 0) {\n            throw new Error(\"bufferRatioFirst must be a finite non-negative value.\");\n        }\n        if (!Number.isFinite(bufferRatioSecond) || bufferRatioSecond < 0) {\n            throw new Error(\"bufferRatioSecond must be a finite non-negative value.\");\n        }\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let frameId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                frameId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                frameId += 1;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    const confidence = detection.confidence ?? 1;\n                    if (confidence >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else if (confidence > MINIMUM_DETECTION_CONFIDENCE) {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const confirmed = [];\n                const unconfirmed = [];\n                const lost = [];\n                for (const track of tracks) {\n                    if (track.timeSinceUpdate > 1)\n                        lost.push(track);\n                    else if (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        confirmed.push(track);\n                    }\n                    else\n                        unconfirmed.push(track);\n                }\n                const assignments = new Map();\n                const pool = [...confirmed, ...lost];\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const firstScores = pairwiseIou(pool.map((track) => track.getRect()), highDetections.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (highDetections[index].confidence ?? 1)));\n                const firstAssociation = associateTrackingScores(firstScores, pool.length, highDetections.length, minimumIouThresholdFirstAssociation);\n                for (const match of firstAssociation.matches) {\n                    updateMatchedTrack(pool[match.trackIndex], highDetections[match.detectionIndex], assignments);\n                }\n                const remainingTracked = firstAssociation.unmatchedTrackIndexes\n                    .map((index) => pool[index])\n                    .filter((track) => track.timeSinceUpdate === 1);\n                const lowDetections = lowDetectionIndexes.map((index) => detections[index]);\n                const secondScores = pairwiseIou(remainingTracked.map((track) => track.getRect()), lowDetections.map((detection) => detection.rect), bufferRatioSecond);\n                const secondAssociation = associateTrackingScores(secondScores, remainingTracked.length, lowDetections.length, minimumIouThresholdSecondAssociation);\n                for (const match of secondAssociation.matches) {\n                    updateMatchedTrack(remainingTracked[match.trackIndex], lowDetections[match.detectionIndex], assignments);\n                }\n                let unmatchedHighLocal = [...firstAssociation.unmatchedDetectionIndexes];\n                let unmatchedUnconfirmed = unconfirmed.map((_, index) => index);\n                if (unconfirmed.length > 0 && unmatchedHighLocal.length > 0) {\n                    const remainingHigh = unmatchedHighLocal.map((index) => highDetections[index]);\n                    const unconfirmedScores = pairwiseIou(unconfirmed.map((track) => track.getRect()), remainingHigh.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (remainingHigh[index].confidence ?? 1)));\n                    const unconfirmedAssociation = associateTrackingScores(unconfirmedScores, unconfirmed.length, remainingHigh.length, minimumIouThresholdUnconfirmedAssociation);\n                    unmatchedUnconfirmed = unconfirmedAssociation.unmatchedTrackIndexes;\n                    for (const match of unconfirmedAssociation.matches) {\n                        updateMatchedTrack(unconfirmed[match.trackIndex], remainingHigh[match.detectionIndex], assignments);\n                    }\n                    unmatchedHighLocal =\n                        unconfirmedAssociation.unmatchedDetectionIndexes.map((index) => unmatchedHighLocal[index]);\n                }\n                const unmatchedUnconfirmedTracks = new Set(unmatchedUnconfirmed.map((index) => unconfirmed[index]));\n                tracks = tracks.filter((track) => !unmatchedUnconfirmedTracks.has(track));\n                for (const localIndex of unmatchedHighLocal) {\n                    const detection = highDetections[localIndex];\n                    if ((detection.confidence ?? 1) < trackActivationThreshold)\n                        continue;\n                    const track = new CBIoUTrack(detection);\n                    if (frameId === 1 && instantFirstFrameActivation) {\n                        track.trackerId = nextTrackerId++;\n                        assignments.set(detection.detectionIndex, track.trackerId);\n                    }\n                    tracks.push(track);\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.timeSinceUpdate === 0 ||\n                        track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames));\n                return createUpdate(detections, assignments, tracks);\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId++;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function createUpdate(detections, assignments, tracks) {\n        const resolvedAssignments = detections.flatMap((detection) => {\n            const trackerId = assignments.get(detection.detectionIndex);\n            return trackerId === undefined\n                ? []\n                : [{ detectionIndex: detection.detectionIndex, trackerId }];\n        });\n        return {\n            activeTrackCount: tracks.length,\n            assignments: resolvedAssignments,\n            confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined)\n                .length,\n        };\n    }\n\n    class OCSortTrack {\n        deltaT;\n        age = 0;\n        lastObservation;\n        trackerId;\n        successfulConsecutiveUpdates = 0;\n        timeSinceUpdate = 0;\n        velocity;\n        frozenState;\n        observed = true;\n        observations = new Map();\n        estimator;\n        constructor(initial, deltaT) {\n            this.deltaT = deltaT;\n            this.lastObservation = initial;\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycsr\");\n            this.configureNoise();\n        }\n        predict(frameStep, frameRate) {\n            if (this.observed && this.timeSinceUpdate > 0) {\n                this.frozenState = this.estimator.snapshot();\n                this.observed = false;\n            }\n            this.estimator.predict(frameStep, frameRate);\n            if (this.timeSinceUpdate > 0) {\n                this.successfulConsecutiveUpdates = 0;\n            }\n            this.timeSinceUpdate += 1;\n            this.age += 1;\n        }\n        update(detection, frameStep, frameRate) {\n            const previous = this.getPreviousObservation();\n            if (previous) {\n                this.velocity = computeVelocity(previous, detection);\n            }\n            if (!this.observed && this.frozenState) {\n                this.unfreeze(detection, frameStep, frameRate);\n            }\n            this.estimator.update(detection.rect);\n            this.observed = true;\n            this.timeSinceUpdate = 0;\n            this.successfulConsecutiveUpdates += 1;\n            this.lastObservation = detection;\n            this.observations.set(this.age, detection);\n            const cutoff = this.age - this.deltaT;\n            for (const age of this.observations.keys()) {\n                if (age < cutoff)\n                    this.observations.delete(age);\n            }\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        getPreviousObservation() {\n            if (this.observations.size === 0)\n                return undefined;\n            for (let index = 0; index < this.deltaT; index += 1) {\n                const delta = this.deltaT - index;\n                const observation = this.observations.get(this.age - delta);\n                if (observation)\n                    return observation;\n            }\n            const latestAge = Math.max(...this.observations.keys());\n            return this.observations.get(latestAge);\n        }\n        configureNoise() {\n            const measurementNoise = identity(4);\n            for (let index = 2; index < 4; index += 1) {\n                measurementNoise[index][index] *= 10;\n            }\n            const covariance = scaleMatrix(identity(7), 10);\n            for (let index = 4; index < 7; index += 1) {\n                covariance[index][index] *= 1000;\n            }\n            const processNoise = identity(7);\n            processNoise[6][6] *= 0.01;\n            for (let index = 4; index < 7; index += 1) {\n                processNoise[index][index] *= 0.01;\n            }\n            this.estimator.setCovariances({\n                covariance,\n                measurementNoise,\n                processNoise,\n            });\n        }\n        unfreeze(detection, frameStep, frameRate) {\n            if (!this.frozenState || this.timeSinceUpdate === 0)\n                return;\n            this.estimator.restore(this.frozenState);\n            const timeGap = this.timeSinceUpdate;\n            const start = rectToMeasurement(this.lastObservation.rect, \"xcycsr\");\n            const end = rectToMeasurement(detection.rect, \"xcycsr\");\n            const startWidth = Math.sqrt(start[2] * start[3]);\n            const startHeight = start[3] === 0 ? 0 : Math.sqrt(start[2] / start[3]);\n            const endWidth = Math.sqrt(end[2] * end[3]);\n            const endHeight = end[3] === 0 ? 0 : Math.sqrt(end[2] / end[3]);\n            for (let index = 0; index < timeGap; index += 1) {\n                const progress = (index + 1) / timeGap;\n                const x = start[0] + progress * (end[0] - start[0]);\n                const y = start[1] + progress * (end[1] - start[1]);\n                const width = startWidth + progress * (endWidth - startWidth);\n                const height = startHeight + progress * (endHeight - startHeight);\n                this.estimator.updateMeasurement([x, y, width * height, width / height]);\n                if (index < timeGap - 1) {\n                    this.estimator.predict(frameStep, frameRate);\n                }\n            }\n            this.frozenState = undefined;\n        }\n    }\n    /** Creates the observation-centric SORT implementation from roboflow/trackers. */\n    function createOCSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        const directionConsistencyWeight = options.directionConsistencyWeight ?? 0.2;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const deltaT = normalizePositiveInteger$1(options.deltaT ?? 3, \"deltaT\");\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(directionConsistencyWeight, \"directionConsistencyWeight\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let frameCount = 0;\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                frameCount = 0;\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                // Match roboflow/trackers: an empty stream before any track exists is\n                // not part of OC-SORT's early-sequence activation window.\n                if (tracks.length === 0 && detections.length === 0) {\n                    return {\n                        activeTrackCount: 0,\n                        assignments: [],\n                        confirmedTrackCount: 0,\n                    };\n                }\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = detections.flatMap((detection, index) => detection.confidence === undefined ||\n                    detection.confidence >= highConfidenceDetectionThreshold\n                    ? [index]\n                    : []);\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const iouScores = pairwiseIou(tracks.map((track) => track.getRect()), highDetections.map((detection) => detection.rect));\n                const combinedScores = iouScores.map((row, trackIndex) => row.map((iou, detectionIndex) => {\n                    if (directionConsistencyWeight === 0)\n                        return iou;\n                    return (iou +\n                        directionConsistencyWeight *\n                            directionConsistency(tracks[trackIndex], highDetections[detectionIndex]) *\n                            (highDetections[detectionIndex].confidence ?? 1));\n                }));\n                const primary = associateTrackingScores(combinedScores, tracks.length, highDetections.length, minimumIouThreshold, iouScores);\n                const assignments = new Map();\n                for (const match of primary.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], highDetections[match.detectionIndex], assignments, frameStep);\n                }\n                let remainingHigh = [...primary.unmatchedDetectionIndexes];\n                if (primary.unmatchedTrackIndexes.length > 0 &&\n                    remainingHigh.length > 0) {\n                    const unmatchedTracks = primary.unmatchedTrackIndexes.map((index) => tracks[index]);\n                    const unmatchedDetections = remainingHigh.map((index) => highDetections[index]);\n                    const recoveryScores = pairwiseIou(unmatchedTracks.map((track) => track.lastObservation.rect), unmatchedDetections.map((detection) => detection.rect));\n                    const recovery = associateTrackingScores(recoveryScores, unmatchedTracks.length, unmatchedDetections.length, minimumIouThreshold);\n                    for (const match of recovery.matches) {\n                        updateMatchedTrack(unmatchedTracks[match.trackIndex], unmatchedDetections[match.detectionIndex], assignments, frameStep);\n                    }\n                    remainingHigh = recovery.unmatchedDetectionIndexes.map((index) => remainingHigh[index]);\n                }\n                for (const localIndex of remainingHigh) {\n                    tracks.push(new OCSortTrack(highDetections[localIndex], deltaT));\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate);\n                frameCount += 1;\n                const resolvedAssignments = detections.flatMap((detection) => {\n                    const trackerId = assignments.get(detection.detectionIndex);\n                    return trackerId === undefined\n                        ? []\n                        : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                });\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: resolvedAssignments,\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments, frameStep) {\n            track.update(detection, frameStep, frameRate);\n            const earlySequence = frameCount <= minimumConsecutiveFrames;\n            const shouldEmit = (earlySequence && track.timeSinceUpdate === 0) ||\n                track.successfulConsecutiveUpdates >= minimumConsecutiveFrames;\n            if (shouldEmit) {\n                if (track.trackerId === undefined) {\n                    track.trackerId = nextTrackerId++;\n                }\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function computeVelocity(previous, current) {\n        const deltaX = current.rect.x - previous.rect.x;\n        const deltaY = current.rect.y - previous.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        return { x: deltaX / norm, y: deltaY / norm };\n    }\n    function directionConsistency(track, detection) {\n        if (!track.velocity)\n            return 0;\n        const reference = track.getPreviousObservation() ?? track.lastObservation;\n        const deltaX = detection.rect.x - reference.rect.x;\n        const deltaY = detection.rect.y - reference.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        const cosine = Math.max(-1, Math.min(1, track.velocity.x * (deltaX / norm) + track.velocity.y * (deltaY / norm)));\n        const angle = Math.acos(cosine);\n        return (Math.PI / 2 - Math.abs(angle)) / Math.PI;\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createSortTracker(options = {}) {\n        return createSortTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createByteTrackTracker(options = {}) {\n        return createByteTrackTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createCBIoUTracker(options = {}) {\n        return createCBIoUTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createOCSortTracker(options = {}) {\n        return createOCSortTracker$1(options);\n    }\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read at all. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, which the detection gate does and the\n     * render-preparation gate does not.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n        /** Playback waits to begin; frames after that are not held. */\n        PlaybackGateReach[\"StartOfPlayback\"] = \"startOfPlayback\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    let tracker;\n    self.addEventListener(\"message\", (event) => {\n        const request = event.data;\n        try {\n            let response;\n            if (request.type === \"configure\") {\n                switch (request.processor.algorithm) {\n                    case \"bytetrack\":\n                        tracker = createByteTrackTracker(request.processor.options);\n                        break;\n                    case \"cbiou\":\n                        tracker = createCBIoUTracker(request.processor.options);\n                        break;\n                    case \"ocsort\":\n                        tracker = createOCSortTracker(request.processor.options);\n                        break;\n                    default:\n                        tracker = createSortTracker(request.processor.options);\n                }\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else if (request.type === \"reset\") {\n                tracker?.reset();\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else {\n                if (!tracker) {\n                    throw new Error(\"Tracking worker is not configured.\");\n                }\n                const startedAt = performance.now();\n                const update = tracker.update(request.detections, request.frameIndex);\n                response = {\n                    ...update,\n                    durationMs: performance.now() - startedAt,\n                    requestId: request.requestId,\n                    type: \"success\",\n                };\n            }\n            self.postMessage(response);\n        }\n        catch (error) {\n            self.postMessage({\n                message: error instanceof Error ? error.message : \"Tracking worker failed.\",\n                requestId: request.requestId,\n                type: \"error\",\n            });\n        }\n    });\n\n})();";
+const EMBEDDED_TRACKING_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /**\n     * Creates one stateful SORT tracker for a single ordered media sequence.\n     *\n     * Defaults, lifecycle semantics, and observation-only output mirror\n     * roboflow/trackers SORT. Motion predictions remain internal to association.\n     */\n    function createSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.25;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                const predicted = tracks.map((track) => track.predict(frameStep, frameRate));\n                const { matches, unmatchedDetections } = associateDetectionsToTracks(detections, predicted, minimumIouThreshold);\n                const trackerIds = new Map();\n                for (const match of matches) {\n                    const track = tracks[match.trackIndex];\n                    const detection = detections[match.detectionIndex];\n                    track.update(detection);\n                    if (track.trackerId === undefined &&\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        track.trackerId = nextTrackerId;\n                        nextTrackerId += 1;\n                    }\n                    if (track.trackerId !== undefined) {\n                        trackerIds.set(detection.detectionIndex, track.trackerId);\n                    }\n                }\n                for (const detectionIndex of unmatchedDetections) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection));\n                    }\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = trackerIds.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n    }\n    class KalmanBoxTrack {\n        consecutiveUpdates;\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        state;\n        covariance = identity(8);\n        constructor(detection, consecutiveUpdates = false) {\n            this.consecutiveUpdates = consecutiveUpdates;\n            this.state = [...rectToXyxy(detection.rect), 0, 0, 0, 0].map((value) => [\n                value,\n            ]);\n        }\n        predict(frameStep, frameRate) {\n            if (this.consecutiveUpdates && this.timeSinceUpdate > 0) {\n                this.successfulUpdates = 0;\n            }\n            const transition = identity(8);\n            for (let index = 0; index < 4; index += 1) {\n                transition[index][index + 4] = frameStep;\n            }\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), createProcessNoise(frameStep, frameRate));\n            // Python SORT counts update calls for the fixed-rate lost-track budget.\n            this.timeSinceUpdate += 1;\n            return stateToRect(this.state);\n        }\n        update(detection) {\n            const measurement = rectToXyxy(detection.rect).map((value) => [value]);\n            const observation = [\n                [1, 0, 0, 0, 0, 0, 0, 0],\n                [0, 1, 0, 0, 0, 0, 0, 0],\n                [0, 0, 1, 0, 0, 0, 0, 0],\n                [0, 0, 0, 1, 0, 0, 0, 0],\n            ];\n            const measurementNoise = scale(identity(4), 0.1);\n            const innovation = subtract(measurement, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(8), multiply(gain, observation));\n            // Joseph form matches the Python implementation and is more stable.\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, measurementNoise), transpose(gain)));\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getStateRect() {\n            return stateToRect(this.state);\n        }\n    }\n    function associateDetectionsToTracks(detections, predicted, minimumIouThreshold) {\n        if (predicted.length === 0 || detections.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetections: detections.map((_, index) => index),\n            };\n        }\n        // Python SORT associates all detections class-agnostically using standard IoU.\n        const scores = predicted.map((rect) => detections.map((detection) => intersectionOverUnion(rect, detection.rect)));\n        const candidateMatches = maximizeAssignment(scores);\n        const matches = [];\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of candidateMatches) {\n            if (scores[trackIndex][detectionIndex] < minimumIouThreshold)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetections: detections.flatMap((_, index) => matchedDetections.has(index) ? [] : [index]),\n        };\n    }\n    /** Hungarian assignment for a rectangular score matrix. */\n    function maximizeAssignment(scores) {\n        if (scores.length === 0 || scores[0]?.length === 0) {\n            return [];\n        }\n        const rowCount = scores.length;\n        const columnCount = scores[0].length;\n        const transposed = rowCount > columnCount;\n        const costs = transposed\n            ? Array.from({ length: columnCount }, (_, row) => Array.from({ length: rowCount }, (_, column) => 1 - scores[column][row]))\n            : scores.map((row) => row.map((score) => 1 - score));\n        const rows = costs.length;\n        const columns = costs[0].length;\n        const u = new Array(rows + 1).fill(0);\n        const v = new Array(columns + 1).fill(0);\n        const p = new Array(columns + 1).fill(0);\n        const way = new Array(columns + 1).fill(0);\n        for (let row = 1; row <= rows; row += 1) {\n            p[0] = row;\n            let column0 = 0;\n            const minValue = new Array(columns + 1).fill(Number.POSITIVE_INFINITY);\n            const used = new Array(columns + 1).fill(false);\n            do {\n                used[column0] = true;\n                const row0 = p[column0];\n                let delta = Number.POSITIVE_INFINITY;\n                let column1 = 0;\n                for (let column = 1; column <= columns; column += 1) {\n                    if (used[column])\n                        continue;\n                    const current = costs[row0 - 1][column - 1] - u[row0] - v[column];\n                    if (current < minValue[column]) {\n                        minValue[column] = current;\n                        way[column] = column0;\n                    }\n                    if (minValue[column] < delta) {\n                        delta = minValue[column];\n                        column1 = column;\n                    }\n                }\n                for (let column = 0; column <= columns; column += 1) {\n                    if (used[column]) {\n                        u[p[column]] += delta;\n                        v[column] -= delta;\n                    }\n                    else {\n                        minValue[column] -= delta;\n                    }\n                }\n                column0 = column1;\n            } while (p[column0] !== 0);\n            do {\n                const column1 = way[column0];\n                p[column0] = p[column1];\n                column0 = column1;\n            } while (column0 !== 0);\n        }\n        const assignments = [];\n        for (let column = 1; column <= columns; column += 1) {\n            if (p[column] === 0)\n                continue;\n            const row = p[column] - 1;\n            assignments.push(transposed ? [column - 1, row] : [row, column - 1]);\n        }\n        return assignments;\n    }\n    function rectToXyxy(rect) {\n        return [\n            rect.x - rect.width / 2,\n            rect.y - rect.height / 2,\n            rect.x + rect.width / 2,\n            rect.y + rect.height / 2,\n        ];\n    }\n    function stateToRect(state) {\n        // The Python XYXY estimator intentionally leaves corner velocities\n        // unconstrained. Normalize only at the browser Rect boundary so a crossing\n        // prediction cannot violate the positive-width/height storage contract.\n        const x1 = Math.min(state[0][0], state[2][0]);\n        const y1 = Math.min(state[1][0], state[3][0]);\n        const x2 = Math.max(state[0][0], state[2][0]);\n        const y2 = Math.max(state[1][0], state[3][0]);\n        return {\n            height: Math.max(Number.EPSILON, y2 - y1),\n            width: Math.max(Number.EPSILON, x2 - x1),\n            x: (x1 + x2) / 2,\n            y: (y1 + y2) / 2,\n        };\n    }\n    function createProcessNoise(frameStep, frameRate) {\n        if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n            return scale(identity(8), 0.01);\n        }\n        const result = Array.from({ length: 8 }, () => new Array(8).fill(0));\n        const dt2 = frameStep * frameStep;\n        const dt3 = dt2 * frameStep;\n        const dt4 = dt2 * dt2;\n        for (let index = 0; index < 4; index += 1) {\n            const velocityIndex = index + 4;\n            result[index][index] = (0.01 * dt4) / 4;\n            result[index][velocityIndex] = (0.01 * dt3) / 2;\n            result[velocityIndex][index] = (0.01 * dt3) / 2;\n            result[velocityIndex][velocityIndex] = 0.01 * dt2;\n        }\n        return result;\n    }\n    function intersectionOverUnion(left, right) {\n        const leftX = left.x - left.width / 2;\n        const leftY = left.y - left.height / 2;\n        const rightX = right.x - right.width / 2;\n        const rightY = right.y - right.height / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + left.width, rightX + right.width) -\n            Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + left.height, rightY + right.height) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = left.width * left.height + right.width * right.height - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n    function resolveFrameStep(current, previous) {\n        if (current === undefined || previous === undefined)\n            return 1;\n        return Math.max(1, current - previous);\n    }\n    function normalizePositiveInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 1) {\n            throw new Error(`${label} must be a positive integer.`);\n        }\n        return value;\n    }\n    function normalizeNonNegativeInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 0) {\n            throw new Error(`${label} must be a non-negative integer.`);\n        }\n        return value;\n    }\n    function normalizeUnitInterval$1(value, label) {\n        if (!Number.isFinite(value) || value < 0 || value > 1) {\n            throw new Error(`${label} must be between 0 and 1.`);\n        }\n    }\n    function identity(size) {\n        return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));\n    }\n    function scale(matrix, factor) {\n        return matrix.map((row) => row.map((value) => value * factor));\n    }\n    function transpose(matrix) {\n        return matrix[0].map((_, column) => matrix.map((row) => row[column]));\n    }\n    function add(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value + right[rowIndex][columnIndex]));\n    }\n    function subtract(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value - right[rowIndex][columnIndex]));\n    }\n    function multiply(left, right) {\n        return left.map((row) => right[0].map((_, column) => row.reduce((sum, value, index) => sum + value * right[index][column], 0)));\n    }\n    function inverse(matrix) {\n        const size = matrix.length;\n        const augmented = matrix.map((row, index) => [\n            ...row,\n            ...identity(size)[index],\n        ]);\n        for (let column = 0; column < size; column += 1) {\n            let pivot = column;\n            for (let row = column + 1; row < size; row += 1) {\n                if (Math.abs(augmented[row][column]) >\n                    Math.abs(augmented[pivot][column])) {\n                    pivot = row;\n                }\n            }\n            if (Math.abs(augmented[pivot][column]) < 1e-12) {\n                throw new Error(\"SORT Kalman covariance is singular.\");\n            }\n            [augmented[column], augmented[pivot]] = [\n                augmented[pivot],\n                augmented[column],\n            ];\n            const divisor = augmented[column][column];\n            augmented[column] = augmented[column].map((value) => value / divisor);\n            for (let row = 0; row < size; row += 1) {\n                if (row === column)\n                    continue;\n                const factor = augmented[row][column];\n                augmented[row] = augmented[row].map((value, index) => value - factor * augmented[column][index]);\n            }\n        }\n        return augmented.map((row) => row.slice(size));\n    }\n\n    /**\n     * Creates one stateful ByteTrack tracker for a single ordered media sequence.\n     *\n     * Defaults and two-stage association mirror roboflow/trackers ByteTrack at\n     * source commit 60b21c8a48676784085fbee455559f16b75a7c9a.\n     * Motion predictions remain internal; only observed detections receive IDs.\n     */\n    function createByteTrackTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.1;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    if ((detection.confidence ?? 1) >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const assignments = new Map();\n                const firstStage = associate(tracks, detections, highDetectionIndexes, minimumIouThreshold);\n                for (const match of firstStage.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                const remainingTracks = firstStage.unmatchedTrackIndexes.map((index) => tracks[index]);\n                const secondStage = associate(remainingTracks, detections, lowDetectionIndexes, minimumIouThreshold);\n                for (const match of secondStage.matches) {\n                    updateMatchedTrack(remainingTracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                // Only unmatched high-confidence observations can start a track.\n                for (const detectionIndex of firstStage.unmatchedDetectionIndexes) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection, true));\n                    }\n                }\n                // Confirmation is sticky once an ID has been allocated. An unmatched\n                // unconfirmed track is discarded immediately, as in Python ByteTrack.\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = assignments.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId;\n                nextTrackerId += 1;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function associate(tracks, detections, detectionIndexes, minimumIouThreshold) {\n        if (tracks.length === 0 || detectionIndexes.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetectionIndexes: [...detectionIndexes],\n                unmatchedTrackIndexes: tracks.map((_, index) => index),\n            };\n        }\n        const scores = tracks.map((track) => {\n            const predictedRect = track.getStateRect();\n            return detectionIndexes.map((detectionIndex) => intersectionOverUnion(predictedRect, detections[detectionIndex].rect));\n        });\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, localDetectionIndex] of maximizeAssignment(scores)) {\n            if (scores[trackIndex][localDetectionIndex] < minimumIouThreshold) {\n                continue;\n            }\n            const detectionIndex = detectionIndexes[localDetectionIndex];\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: detectionIndexes.filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: tracks.flatMap((_, index) => matchedTracks.has(index) ? [] : [index]),\n        };\n    }\n\n    function associateTrackingScores(scores, trackCount, detectionCount, minimumScore, acceptanceScores = scores) {\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of maximizeAssignment(scores)) {\n            if (acceptanceScores[trackIndex][detectionIndex] < minimumScore)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: Array.from({ length: detectionCount }, (_, index) => index).filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: Array.from({ length: trackCount }, (_, index) => index).filter((index) => !matchedTracks.has(index)),\n        };\n    }\n    function pairwiseIou(tracks, detections, bufferRatio = 0) {\n        return tracks.map((track) => detections.map((detection) => bufferedIntersectionOverUnion(track, detection, bufferRatio)));\n    }\n    function bufferedIntersectionOverUnion(left, right, bufferRatio) {\n        const leftWidth = left.width * (1 + 2 * bufferRatio);\n        const leftHeight = left.height * (1 + 2 * bufferRatio);\n        const rightWidth = right.width * (1 + 2 * bufferRatio);\n        const rightHeight = right.height * (1 + 2 * bufferRatio);\n        const leftX = left.x - leftWidth / 2;\n        const leftY = left.y - leftHeight / 2;\n        const rightX = right.x - rightWidth / 2;\n        const rightY = right.y - rightHeight / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + leftWidth, rightX + rightWidth) - Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + leftHeight, rightY + rightHeight) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = leftWidth * leftHeight + rightWidth * rightHeight - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n\n    /**\n     * Kalman state estimator shared by the browser C-BIoU and OC-SORT ports.\n     * Its layouts, covariance update, and gap-scaled constant-velocity model\n     * mirror roboflow/trackers at 60b21c8.\n     */\n    class TrackingKalmanEstimator {\n        representation;\n        dimension;\n        measurementDimension = 4;\n        covariance;\n        measurementNoise = identity(4);\n        processNoise;\n        state;\n        baselineProcessNoise;\n        positionIndexes;\n        velocityIndexes;\n        constructor(initialRect, representation) {\n            this.representation = representation;\n            const measurement = rectToMeasurement(initialRect, representation);\n            this.dimension = representation === \"xcycsr\" ? 7 : 8;\n            this.positionIndexes =\n                representation === \"xcycsr\" ? [0, 1, 2] : [0, 1, 2, 3];\n            this.velocityIndexes =\n                representation === \"xcycsr\" ? [4, 5, 6] : [4, 5, 6, 7];\n            this.state = Array.from({ length: this.dimension }, (_, index) => [\n                measurement[index] ?? 0,\n            ]);\n            this.covariance = identity(this.dimension);\n            this.processNoise = identity(this.dimension);\n            this.baselineProcessNoise = identity(this.dimension);\n        }\n        predict(frameStep, frameRate) {\n            if (this.representation === \"xcycsr\" &&\n                this.state[2][0] + frameStep * this.state[6][0] <= 0) {\n                this.state[6][0] = 0;\n            }\n            const transition = identity(this.dimension);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                transition[positionIndex][this.velocityIndexes[index]] = frameStep;\n            });\n            this.processNoise = this.createProcessNoise(frameStep, frameRate);\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), this.processNoise);\n        }\n        update(rect) {\n            this.updateMeasurement(rectToMeasurement(rect, this.representation));\n        }\n        updateMeasurement(measurement) {\n            const observation = Array.from({ length: 4 }, (_, row) => Array.from({ length: this.dimension }, (_, column) => row === column ? 1 : 0));\n            const measurementColumn = measurement.map((value) => [value]);\n            const innovation = subtract(measurementColumn, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), this.measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(this.dimension), multiply(gain, observation));\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, this.measurementNoise), transpose(gain)));\n        }\n        getRect() {\n            return measurementToRect(this.state.slice(0, 4).map((row) => row[0]), this.representation);\n        }\n        setCovariances(options) {\n            if (options.covariance)\n                this.covariance = clone(options.covariance);\n            if (options.measurementNoise) {\n                this.measurementNoise = clone(options.measurementNoise);\n            }\n            if (options.processNoise) {\n                this.processNoise = clone(options.processNoise);\n                this.baselineProcessNoise = clone(options.processNoise);\n            }\n        }\n        snapshot() {\n            return {\n                covariance: clone(this.covariance),\n                measurementNoise: clone(this.measurementNoise),\n                processNoise: clone(this.processNoise),\n                state: clone(this.state),\n            };\n        }\n        restore(snapshot) {\n            this.covariance = clone(snapshot.covariance);\n            this.measurementNoise = clone(snapshot.measurementNoise);\n            this.processNoise = clone(snapshot.processNoise);\n            this.state = clone(snapshot.state);\n        }\n        createProcessNoise(frameStep, frameRate) {\n            if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n                return clone(this.baselineProcessNoise);\n            }\n            const result = Array.from({ length: this.dimension }, () => new Array(this.dimension).fill(0));\n            const dt2 = frameStep * frameStep;\n            const dt3 = dt2 * frameStep;\n            const dt4 = dt2 * dt2;\n            const kinematicIndexes = new Set([\n                ...this.positionIndexes,\n                ...this.velocityIndexes,\n            ]);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                const velocityIndex = this.velocityIndexes[index];\n                const accelerationVariance = this.baselineProcessNoise[velocityIndex][velocityIndex];\n                result[positionIndex][positionIndex] = (accelerationVariance * dt4) / 4;\n                result[positionIndex][velocityIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][positionIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][velocityIndex] = accelerationVariance * dt2;\n            });\n            for (let index = 0; index < this.dimension; index += 1) {\n                if (!kinematicIndexes.has(index)) {\n                    result[index][index] = this.baselineProcessNoise[index][index];\n                }\n            }\n            return result;\n        }\n    }\n    function rectToMeasurement(rect, representation) {\n        if (representation === \"xcycwh\") {\n            return [rect.x, rect.y, rect.width, rect.height];\n        }\n        return [\n            rect.x,\n            rect.y,\n            rect.width * rect.height,\n            rect.width / (rect.height + 1e-6),\n        ];\n    }\n    function measurementToRect(measurement, representation) {\n        const [x, y, third, fourth] = measurement;\n        if (representation === \"xcycwh\") {\n            return {\n                height: Math.max(1e-3, fourth),\n                width: Math.max(1e-3, third),\n                x,\n                y,\n            };\n        }\n        const width = Math.sqrt(third * fourth);\n        const height = width === 0 ? 0 : third / width;\n        return {\n            height: Math.max(Number.EPSILON, height),\n            width: Math.max(Number.EPSILON, width),\n            x,\n            y,\n        };\n    }\n    function diagonal(values) {\n        return values.map((value, row) => values.map((_, column) => (row === column ? value : 0)));\n    }\n    function scaleMatrix(matrix, factor) {\n        return scale(matrix, factor);\n    }\n    function clone(matrix) {\n        return matrix.map((row) => [...row]);\n    }\n\n    const MINIMUM_DETECTION_CONFIDENCE = 0.1;\n    class CBIoUTrack {\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        estimator;\n        constructor(initial) {\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycwh\");\n            this.setInitialNoise(initial.rect.width, initial.rect.height);\n        }\n        predict(frameStep, frameRate) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                processNoise: this.buildProcessNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.predict(frameStep, frameRate);\n            this.clampState();\n            this.timeSinceUpdate += 1;\n        }\n        update(detection) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                measurementNoise: this.buildMeasurementNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.update(detection.rect);\n            this.clampState();\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        setInitialNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            this.estimator.setCovariances({\n                covariance: diagonal([\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                ]),\n                measurementNoise: this.buildMeasurementNoise(width, height),\n                processNoise: this.buildProcessNoise(width, height),\n            });\n        }\n        buildProcessNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            return diagonal([\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n            ]);\n        }\n        buildMeasurementNoise(width, height) {\n            const sigmaMeasurement = 0.05;\n            return diagonal([\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n            ]);\n        }\n        clampState() {\n            this.estimator.state[2][0] = Math.max(this.estimator.state[2][0], 1e-3);\n            this.estimator.state[3][0] = Math.max(this.estimator.state[3][0], 1e-3);\n        }\n    }\n    /** Creates the detection-only C-BIoU implementation from roboflow/trackers. */\n    function createCBIoUTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ?? 0.2;\n        const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ?? 0.5;\n        const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ?? 0.3;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const instantFirstFrameActivation = options.instantFirstFrameActivation ?? true;\n        const bufferRatioFirst = options.bufferRatioFirst ?? 0.3;\n        const bufferRatioSecond = options.bufferRatioSecond ?? 0.5;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThresholdFirstAssociation, \"minimumIouThresholdFirstAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdSecondAssociation, \"minimumIouThresholdSecondAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdUnconfirmedAssociation, \"minimumIouThresholdUnconfirmedAssociation\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        if (!Number.isFinite(bufferRatioFirst) || bufferRatioFirst < 0) {\n            throw new Error(\"bufferRatioFirst must be a finite non-negative value.\");\n        }\n        if (!Number.isFinite(bufferRatioSecond) || bufferRatioSecond < 0) {\n            throw new Error(\"bufferRatioSecond must be a finite non-negative value.\");\n        }\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let frameId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                frameId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                frameId += 1;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    const confidence = detection.confidence ?? 1;\n                    if (confidence >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else if (confidence > MINIMUM_DETECTION_CONFIDENCE) {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const confirmed = [];\n                const unconfirmed = [];\n                const lost = [];\n                for (const track of tracks) {\n                    if (track.timeSinceUpdate > 1)\n                        lost.push(track);\n                    else if (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        confirmed.push(track);\n                    }\n                    else\n                        unconfirmed.push(track);\n                }\n                const assignments = new Map();\n                const pool = [...confirmed, ...lost];\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const firstScores = pairwiseIou(pool.map((track) => track.getRect()), highDetections.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (highDetections[index].confidence ?? 1)));\n                const firstAssociation = associateTrackingScores(firstScores, pool.length, highDetections.length, minimumIouThresholdFirstAssociation);\n                for (const match of firstAssociation.matches) {\n                    updateMatchedTrack(pool[match.trackIndex], highDetections[match.detectionIndex], assignments);\n                }\n                const remainingTracked = firstAssociation.unmatchedTrackIndexes\n                    .map((index) => pool[index])\n                    .filter((track) => track.timeSinceUpdate === 1);\n                const lowDetections = lowDetectionIndexes.map((index) => detections[index]);\n                const secondScores = pairwiseIou(remainingTracked.map((track) => track.getRect()), lowDetections.map((detection) => detection.rect), bufferRatioSecond);\n                const secondAssociation = associateTrackingScores(secondScores, remainingTracked.length, lowDetections.length, minimumIouThresholdSecondAssociation);\n                for (const match of secondAssociation.matches) {\n                    updateMatchedTrack(remainingTracked[match.trackIndex], lowDetections[match.detectionIndex], assignments);\n                }\n                let unmatchedHighLocal = [...firstAssociation.unmatchedDetectionIndexes];\n                let unmatchedUnconfirmed = unconfirmed.map((_, index) => index);\n                if (unconfirmed.length > 0 && unmatchedHighLocal.length > 0) {\n                    const remainingHigh = unmatchedHighLocal.map((index) => highDetections[index]);\n                    const unconfirmedScores = pairwiseIou(unconfirmed.map((track) => track.getRect()), remainingHigh.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (remainingHigh[index].confidence ?? 1)));\n                    const unconfirmedAssociation = associateTrackingScores(unconfirmedScores, unconfirmed.length, remainingHigh.length, minimumIouThresholdUnconfirmedAssociation);\n                    unmatchedUnconfirmed = unconfirmedAssociation.unmatchedTrackIndexes;\n                    for (const match of unconfirmedAssociation.matches) {\n                        updateMatchedTrack(unconfirmed[match.trackIndex], remainingHigh[match.detectionIndex], assignments);\n                    }\n                    unmatchedHighLocal =\n                        unconfirmedAssociation.unmatchedDetectionIndexes.map((index) => unmatchedHighLocal[index]);\n                }\n                const unmatchedUnconfirmedTracks = new Set(unmatchedUnconfirmed.map((index) => unconfirmed[index]));\n                tracks = tracks.filter((track) => !unmatchedUnconfirmedTracks.has(track));\n                for (const localIndex of unmatchedHighLocal) {\n                    const detection = highDetections[localIndex];\n                    if ((detection.confidence ?? 1) < trackActivationThreshold)\n                        continue;\n                    const track = new CBIoUTrack(detection);\n                    if (frameId === 1 && instantFirstFrameActivation) {\n                        track.trackerId = nextTrackerId++;\n                        assignments.set(detection.detectionIndex, track.trackerId);\n                    }\n                    tracks.push(track);\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.timeSinceUpdate === 0 ||\n                        track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames));\n                return createUpdate(detections, assignments, tracks);\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId++;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function createUpdate(detections, assignments, tracks) {\n        const resolvedAssignments = detections.flatMap((detection) => {\n            const trackerId = assignments.get(detection.detectionIndex);\n            return trackerId === undefined\n                ? []\n                : [{ detectionIndex: detection.detectionIndex, trackerId }];\n        });\n        return {\n            activeTrackCount: tracks.length,\n            assignments: resolvedAssignments,\n            confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined)\n                .length,\n        };\n    }\n\n    class OCSortTrack {\n        deltaT;\n        age = 0;\n        lastObservation;\n        trackerId;\n        successfulConsecutiveUpdates = 0;\n        timeSinceUpdate = 0;\n        velocity;\n        frozenState;\n        observed = true;\n        observations = new Map();\n        estimator;\n        constructor(initial, deltaT) {\n            this.deltaT = deltaT;\n            this.lastObservation = initial;\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycsr\");\n            this.configureNoise();\n        }\n        predict(frameStep, frameRate) {\n            if (this.observed && this.timeSinceUpdate > 0) {\n                this.frozenState = this.estimator.snapshot();\n                this.observed = false;\n            }\n            this.estimator.predict(frameStep, frameRate);\n            if (this.timeSinceUpdate > 0) {\n                this.successfulConsecutiveUpdates = 0;\n            }\n            this.timeSinceUpdate += 1;\n            this.age += 1;\n        }\n        update(detection, frameStep, frameRate) {\n            const previous = this.getPreviousObservation();\n            if (previous) {\n                this.velocity = computeVelocity(previous, detection);\n            }\n            if (!this.observed && this.frozenState) {\n                this.unfreeze(detection, frameStep, frameRate);\n            }\n            this.estimator.update(detection.rect);\n            this.observed = true;\n            this.timeSinceUpdate = 0;\n            this.successfulConsecutiveUpdates += 1;\n            this.lastObservation = detection;\n            this.observations.set(this.age, detection);\n            const cutoff = this.age - this.deltaT;\n            for (const age of this.observations.keys()) {\n                if (age < cutoff)\n                    this.observations.delete(age);\n            }\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        getPreviousObservation() {\n            if (this.observations.size === 0)\n                return undefined;\n            for (let index = 0; index < this.deltaT; index += 1) {\n                const delta = this.deltaT - index;\n                const observation = this.observations.get(this.age - delta);\n                if (observation)\n                    return observation;\n            }\n            const latestAge = Math.max(...this.observations.keys());\n            return this.observations.get(latestAge);\n        }\n        configureNoise() {\n            const measurementNoise = identity(4);\n            for (let index = 2; index < 4; index += 1) {\n                measurementNoise[index][index] *= 10;\n            }\n            const covariance = scaleMatrix(identity(7), 10);\n            for (let index = 4; index < 7; index += 1) {\n                covariance[index][index] *= 1000;\n            }\n            const processNoise = identity(7);\n            processNoise[6][6] *= 0.01;\n            for (let index = 4; index < 7; index += 1) {\n                processNoise[index][index] *= 0.01;\n            }\n            this.estimator.setCovariances({\n                covariance,\n                measurementNoise,\n                processNoise,\n            });\n        }\n        unfreeze(detection, frameStep, frameRate) {\n            if (!this.frozenState || this.timeSinceUpdate === 0)\n                return;\n            this.estimator.restore(this.frozenState);\n            const timeGap = this.timeSinceUpdate;\n            const start = rectToMeasurement(this.lastObservation.rect, \"xcycsr\");\n            const end = rectToMeasurement(detection.rect, \"xcycsr\");\n            const startWidth = Math.sqrt(start[2] * start[3]);\n            const startHeight = start[3] === 0 ? 0 : Math.sqrt(start[2] / start[3]);\n            const endWidth = Math.sqrt(end[2] * end[3]);\n            const endHeight = end[3] === 0 ? 0 : Math.sqrt(end[2] / end[3]);\n            for (let index = 0; index < timeGap; index += 1) {\n                const progress = (index + 1) / timeGap;\n                const x = start[0] + progress * (end[0] - start[0]);\n                const y = start[1] + progress * (end[1] - start[1]);\n                const width = startWidth + progress * (endWidth - startWidth);\n                const height = startHeight + progress * (endHeight - startHeight);\n                this.estimator.updateMeasurement([x, y, width * height, width / height]);\n                if (index < timeGap - 1) {\n                    this.estimator.predict(frameStep, frameRate);\n                }\n            }\n            this.frozenState = undefined;\n        }\n    }\n    /** Creates the observation-centric SORT implementation from roboflow/trackers. */\n    function createOCSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        const directionConsistencyWeight = options.directionConsistencyWeight ?? 0.2;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const deltaT = normalizePositiveInteger$1(options.deltaT ?? 3, \"deltaT\");\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(directionConsistencyWeight, \"directionConsistencyWeight\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let frameCount = 0;\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                frameCount = 0;\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                // Match roboflow/trackers: an empty stream before any track exists is\n                // not part of OC-SORT's early-sequence activation window.\n                if (tracks.length === 0 && detections.length === 0) {\n                    return {\n                        activeTrackCount: 0,\n                        assignments: [],\n                        confirmedTrackCount: 0,\n                    };\n                }\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = detections.flatMap((detection, index) => detection.confidence === undefined ||\n                    detection.confidence >= highConfidenceDetectionThreshold\n                    ? [index]\n                    : []);\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const iouScores = pairwiseIou(tracks.map((track) => track.getRect()), highDetections.map((detection) => detection.rect));\n                const combinedScores = iouScores.map((row, trackIndex) => row.map((iou, detectionIndex) => {\n                    if (directionConsistencyWeight === 0)\n                        return iou;\n                    return (iou +\n                        directionConsistencyWeight *\n                            directionConsistency(tracks[trackIndex], highDetections[detectionIndex]) *\n                            (highDetections[detectionIndex].confidence ?? 1));\n                }));\n                const primary = associateTrackingScores(combinedScores, tracks.length, highDetections.length, minimumIouThreshold, iouScores);\n                const assignments = new Map();\n                for (const match of primary.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], highDetections[match.detectionIndex], assignments, frameStep);\n                }\n                let remainingHigh = [...primary.unmatchedDetectionIndexes];\n                if (primary.unmatchedTrackIndexes.length > 0 &&\n                    remainingHigh.length > 0) {\n                    const unmatchedTracks = primary.unmatchedTrackIndexes.map((index) => tracks[index]);\n                    const unmatchedDetections = remainingHigh.map((index) => highDetections[index]);\n                    const recoveryScores = pairwiseIou(unmatchedTracks.map((track) => track.lastObservation.rect), unmatchedDetections.map((detection) => detection.rect));\n                    const recovery = associateTrackingScores(recoveryScores, unmatchedTracks.length, unmatchedDetections.length, minimumIouThreshold);\n                    for (const match of recovery.matches) {\n                        updateMatchedTrack(unmatchedTracks[match.trackIndex], unmatchedDetections[match.detectionIndex], assignments, frameStep);\n                    }\n                    remainingHigh = recovery.unmatchedDetectionIndexes.map((index) => remainingHigh[index]);\n                }\n                for (const localIndex of remainingHigh) {\n                    tracks.push(new OCSortTrack(highDetections[localIndex], deltaT));\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate);\n                frameCount += 1;\n                const resolvedAssignments = detections.flatMap((detection) => {\n                    const trackerId = assignments.get(detection.detectionIndex);\n                    return trackerId === undefined\n                        ? []\n                        : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                });\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: resolvedAssignments,\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments, frameStep) {\n            track.update(detection, frameStep, frameRate);\n            const earlySequence = frameCount <= minimumConsecutiveFrames;\n            const shouldEmit = (earlySequence && track.timeSinceUpdate === 0) ||\n                track.successfulConsecutiveUpdates >= minimumConsecutiveFrames;\n            if (shouldEmit) {\n                if (track.trackerId === undefined) {\n                    track.trackerId = nextTrackerId++;\n                }\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function computeVelocity(previous, current) {\n        const deltaX = current.rect.x - previous.rect.x;\n        const deltaY = current.rect.y - previous.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        return { x: deltaX / norm, y: deltaY / norm };\n    }\n    function directionConsistency(track, detection) {\n        if (!track.velocity)\n            return 0;\n        const reference = track.getPreviousObservation() ?? track.lastObservation;\n        const deltaX = detection.rect.x - reference.rect.x;\n        const deltaY = detection.rect.y - reference.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        const cosine = Math.max(-1, Math.min(1, track.velocity.x * (deltaX / norm) + track.velocity.y * (deltaY / norm)));\n        const angle = Math.acos(cosine);\n        return (Math.PI / 2 - Math.abs(angle)) / Math.PI;\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createSortTracker(options = {}) {\n        return createSortTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createByteTrackTracker(options = {}) {\n        return createByteTrackTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createCBIoUTracker(options = {}) {\n        return createCBIoUTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createOCSortTracker(options = {}) {\n        return createOCSortTracker$1(options);\n    }\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read, or was refused before any read. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, and a gate that stops one has to bound its own wait\n     * or a producer nothing answers for never runs again.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        /**\n         * The picture is waiting on media the source has not handed over yet, which\n         * is the bytes and their decode rather than anything downstream of them.\n         * `PlaybackBuffering` is what a transport reports once it has already\n         * stopped; this is reported from the read itself, including the reads a seek\n         * makes while the transport still reads as paused.\n         */\n        MediaSessionActivityKind[\"MediaSourceReading\"] = \"mediaSourceReading\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        /**\n         * The render-preparation gate held the picture for artifacts that never\n         * arrived and let it go. Nothing is blocked: the frames reaching the screen\n         * are the ones whose artifacts were given up on. What is waited on is\n         * preparation finishing another frame, which is what lets the gate hold the\n         * picture again; `RenderPreparing` covers the holds that are running.\n         */\n        MediaSessionActivityKind[\"RenderPreparationAbandoned\"] = \"renderPreparationAbandoned\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    let tracker;\n    self.addEventListener(\"message\", (event) => {\n        const request = event.data;\n        try {\n            let response;\n            if (request.type === \"configure\") {\n                switch (request.processor.algorithm) {\n                    case \"bytetrack\":\n                        tracker = createByteTrackTracker(request.processor.options);\n                        break;\n                    case \"cbiou\":\n                        tracker = createCBIoUTracker(request.processor.options);\n                        break;\n                    case \"ocsort\":\n                        tracker = createOCSortTracker(request.processor.options);\n                        break;\n                    default:\n                        tracker = createSortTracker(request.processor.options);\n                }\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else if (request.type === \"reset\") {\n                tracker?.reset();\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else {\n                if (!tracker) {\n                    throw new Error(\"Tracking worker is not configured.\");\n                }\n                const startedAt = performance.now();\n                const update = tracker.update(request.detections, request.frameIndex);\n                response = {\n                    ...update,\n                    durationMs: performance.now() - startedAt,\n                    requestId: request.requestId,\n                    type: \"success\",\n                };\n            }\n            self.postMessage(response);\n        }\n        catch (error) {\n            self.postMessage({\n                message: error instanceof Error ? error.message : \"Tracking worker failed.\",\n                requestId: request.requestId,\n                type: \"error\",\n            });\n        }\n    });\n\n})();";
 
 const DEFAULT_WORKER_NAME$1 = "supervision-detection-post-processing";
 let defaultWorkerUrl$1;
@@ -990,90 +992,6 @@ var MediaProbeIssueCode;
     MediaProbeIssueCode["TargetVideoCannotEncode"] = "targetVideoCannotEncode";
 })(MediaProbeIssueCode || (MediaProbeIssueCode = {}));
 
-/**
- * The kind each coded refusal already stands for. Reading the code beats
- * re-deriving the kind from the message: the text of a container refusal says
- * "demuxer", the text of a wedged worker says "timed out", and the patterns
- * below would file both under the wrong kind. Written as a total record, so a
- * code added to the vocabulary above fails the build until it has a kind.
- */
-const PRODUCER_CODE_KINDS = {
-    ABORTED: MediaErrorKind.Unknown,
-    BACKEND_CRASHED: MediaErrorKind.Decode,
-    CONTAINER_UNREADABLE: MediaErrorKind.Unreadable,
-    DECODER_STALLED: MediaErrorKind.Decode,
-    DECODE_UNSUPPORTED: MediaErrorKind.UnsupportedFormat,
-    NO_VIDEO_TRACK: MediaErrorKind.NoVideoTrack,
-    PRESENTATION_MISMATCH: MediaErrorKind.Unknown,
-    RATE_UNSUPPORTED: MediaErrorKind.Unknown,
-    SOURCE_UNREADABLE: MediaErrorKind.Unreadable,
-    VIDEO_TRACK_UNREADABLE: MediaErrorKind.UnsupportedFormat,
-};
-const UNSUPPORTED_FORMAT_PATTERN = /unsupported|not supported|no (?:matching )?(?:decoder|codec)|codec/i;
-const DECODE_PATTERN = /decod|demux|corrupt|malformed|bitstream/i;
-const NETWORK_PATTERN = /network|fetch|http|failed to load|load failed|timed? ?out|abort/i;
-/**
- * A media failure with a stable, documented kind.
- *
- * Branch on `kind` instead of matching decoder, demuxer, or container message
- * text. `message` stays diagnostic and may name vendor internals; applications
- * own their user-facing copy. The originating failure is preserved on `cause`.
- */
-class MediaSourceError extends Error {
-    kind;
-    constructor(kind, message, options) {
-        super(message, options);
-        this.name = "MediaSourceError";
-        this.kind = kind;
-    }
-}
-function isMediaSourceError(value) {
-    return value instanceof MediaSourceError;
-}
-/**
- * Classifies an arbitrary media failure into a `MediaSourceError`.
- *
- * Already-classified errors pass through so a kind chosen at the point of
- * failure is never downgraded by a broader message match. Anything the
- * heuristics cannot place stays representable as `Unknown` rather than being
- * forced into a wrong kind.
- */
-function toMediaSourceError(error, fallbackMessage = "Media source failed.") {
-    if (isMediaSourceError(error)) {
-        return error;
-    }
-    const message = error instanceof Error ? error.message : fallbackMessage;
-    const kind = producerCodeKind(error) ?? classifyMediaErrorMessage(message);
-    return new MediaSourceError(kind, message, { cause: error });
-}
-/**
- * Failure kind of any caught media failure.
- *
- * A `MediaSourceError` reports the kind chosen where it failed. Anything else
- * is classified from its message, and stays `Unknown` when no kind fits.
- */
-function getMediaErrorKind(error) {
-    return toMediaSourceError(error).kind;
-}
-function producerCodeKind(error) {
-    const code = error?.code;
-    return typeof code === "string" && code in PRODUCER_CODE_KINDS
-        ? PRODUCER_CODE_KINDS[code]
-        : null;
-}
-function classifyMediaErrorMessage(message) {
-    if (NETWORK_PATTERN.test(message)) {
-        return MediaErrorKind.Network;
-    }
-    if (UNSUPPORTED_FORMAT_PATTERN.test(message)) {
-        return MediaErrorKind.UnsupportedFormat;
-    }
-    if (DECODE_PATTERN.test(message)) {
-        return MediaErrorKind.Decode;
-    }
-    return MediaErrorKind.Unknown;
-}
-
 /**
  * Normalizes a decoded media source onto a zero-based presentation timeline.
  *
@@ -1748,531 +1666,6 @@ function formatPreparationErrorMessage(probe) {
         .join(" ")}`;
 }
 
-/**
- * Where a container keeps the table that says which byte range holds which
- * frame.
- */
-var MediaIndexPlacement;
-(function (MediaIndexPlacement) {
-    /** Before the media data, so an open reads it in the first bytes. */
-    MediaIndexPlacement["Front"] = "front";
-    /** After the media data, so an open over a link seeks to the end first. */
-    MediaIndexPlacement["End"] = "end";
-    /** One index per fragment, spread through the file. */
-    MediaIndexPlacement["Fragmented"] = "fragmented";
-    /** Not an ISO base media file, which is the only layout this probe reads. */
-    MediaIndexPlacement["Unknown"] = "unknown";
-})(MediaIndexPlacement || (MediaIndexPlacement = {}));
-/** A fact about a source that conversion could be a response to. */
-var MediaConditionCode;
-(function (MediaConditionCode) {
-    /** The demuxer does not read this file's container. */
-    MediaConditionCode["ContainerUnreadable"] = "containerUnreadable";
-    /** The container opened and the demuxer parsed no track out of it. */
-    MediaConditionCode["VideoTrackUnreadable"] = "videoTrackUnreadable";
-    /** The container's tracks read and none of them carries video. */
-    MediaConditionCode["NoVideoTrack"] = "noVideoTrack";
-    /** A video track the demuxer cannot name a codec for, so no decoder can be
-     *  configured for it whatever the browser supports. */
-    MediaConditionCode["CodecUnnamed"] = "codecUnnamed";
-    /** The codec is named and this browser has no decoder for it. */
-    MediaConditionCode["CodecUndecodable"] = "codecUndecodable";
-    /**
-     * Frames do not arrive on a steady grid: two share a presentation timestamp,
-     * or the gaps between them take more values than a timebase's own rounding
-     * explains. Frame indices reconstructed as `round(time * rate)` name the
-     * wrong frame on such a source.
-     */
-    MediaConditionCode["UnstableFrameTiming"] = "unstableFrameTiming";
-    /** The frame index sits after the media data, so opening over a link pays a
-     *  seek to the end of the file before the first frame. */
-    MediaConditionCode["IndexAtEnd"] = "indexAtEnd";
-    /** The file carries one index per fragment rather than one for the whole. */
-    MediaConditionCode["IndexFragmented"] = "indexFragmented";
-    /** The first frame's presentation timestamp is not zero, so media time and
-     *  elapsed time are different numbers on this source. */
-    MediaConditionCode["NonZeroStart"] = "nonZeroStart";
-})(MediaConditionCode || (MediaConditionCode = {}));
-/** What a condition stands in the way of. */
-var MediaConditionScope;
-(function (MediaConditionScope) {
-    /** Getting a picture on screen at all. */
-    MediaConditionScope["Playback"] = "playback";
-    /** Naming the frame on screen by index, which is how detections are paired. */
-    MediaConditionScope["FrameIndexing"] = "frameIndexing";
-})(MediaConditionScope || (MediaConditionScope = {}));
-/** What to do about a condition. */
-var MediaConditionResponse;
-(function (MediaConditionResponse) {
-    /** Open the source as it is. */
-    MediaConditionResponse["None"] = "none";
-    /** Copy the coded frames into another container without re-encoding them. */
-    MediaConditionResponse["RemuxFirst"] = "remuxFirst";
-    /** Re-encode, and open the result once it is finished. */
-    MediaConditionResponse["ConvertFirst"] = "convertFirst";
-    /** Re-encode, and open the prefix as it is written. */
-    MediaConditionResponse["ConvertProgressively"] = "convertProgressively";
-    /** Do not open it, and say why. */
-    MediaConditionResponse["Refuse"] = "refuse";
-})(MediaConditionResponse || (MediaConditionResponse = {}));
-/** Whether a response leaves the frame sequence detections index intact. */
-var ConversionFrameEffect;
-(function (ConversionFrameEffect) {
-    /** Every source frame comes out, at its own presentation time. */
-    ConversionFrameEffect["Preserved"] = "preserved";
-    /** The output carries a different frame sequence from the source, so a
-     *  detection indexed against the source names a different picture. */
-    ConversionFrameEffect["Resampled"] = "resampled";
-})(ConversionFrameEffect || (ConversionFrameEffect = {}));
-
-/**
- * How many different neighbour gaps a steady source is allowed. One is a source
- * whose rate its timebase states exactly. Two is one whose timebase cannot:
- * 30 fps on a millisecond grain alternates 33 and 34 ticks forever, and 10007
- * ticks a second alternates 333 and 334. Measured across the 89-clip media
- * matrix, every clip that steps correctly sits at one or two and every clip
- * that steps wrong sits at three or more.
- */
-const MAX_STABLE_DISTINCT_GAPS = 2;
-const RESPONSE_STRENGTH = {
-    [MediaConditionResponse.None]: 0,
-    [MediaConditionResponse.RemuxFirst]: 1,
-    [MediaConditionResponse.ConvertProgressively]: 2,
-    [MediaConditionResponse.ConvertFirst]: 3,
-    [MediaConditionResponse.Refuse]: 4,
-};
-/**
- * Which conditions a source's measured facts hold, and what to do about each.
- *
- * Pure: everything it reasons over was measured once by the probe. The two
- * verdicts are separate because the conditions are: a source whose frames do
- * not arrive on a steady grid plays perfectly and cannot be addressed by frame
- * index, and answering that with one verdict would either refuse a clip that
- * plays or hand out indices that name the wrong picture.
- */
-function evaluateMediaConditions(facts, policy = {}) {
-    const conditions = [];
-    if (!facts.container) {
-        conditions.push({
-            code: MediaConditionCode.ContainerUnreadable,
-            detail: "The demuxer does not read this file's container.",
-            frameEffect: null,
-            response: MediaConditionResponse.Refuse,
-            scope: MediaConditionScope.Playback,
-        });
-        return createReport(facts, conditions);
-    }
-    if (facts.videoTrackCount === 0) {
-        conditions.push(facts.trackCount === 0
-            ? {
-                code: MediaConditionCode.VideoTrackUnreadable,
-                detail: "The container opened and the demuxer parsed no track out of it, so whatever video it holds is in a form this build cannot reach.",
-                frameEffect: null,
-                response: MediaConditionResponse.Refuse,
-                scope: MediaConditionScope.Playback,
-            }
-            : {
-                code: MediaConditionCode.NoVideoTrack,
-                detail: `The container's ${facts.trackCount} track(s) read and none of them carries video this build can reach.`,
-                frameEffect: null,
-                response: MediaConditionResponse.Refuse,
-                scope: MediaConditionScope.Playback,
-            });
-        return createReport(facts, conditions);
-    }
-    if (facts.codec === null) {
-        conditions.push({
-            code: MediaConditionCode.CodecUnnamed,
-            detail: "The video track opened and the demuxer cannot name its codec, so no decoder can be configured for it whatever this browser supports.",
-            frameEffect: null,
-            response: MediaConditionResponse.Refuse,
-            scope: MediaConditionScope.Playback,
-        });
-    }
-    else if (facts.canDecode === false) {
-        const progressive = policy.progressiveConversion === true;
-        conditions.push({
-            code: MediaConditionCode.CodecUndecodable,
-            detail: `This browser has no decoder for ${facts.codec}, so the frames have to be re-encoded into one it does.`,
-            frameEffect: ConversionFrameEffect.Resampled,
-            response: progressive
-                ? MediaConditionResponse.ConvertProgressively
-                : MediaConditionResponse.ConvertFirst,
-            scope: MediaConditionScope.Playback,
-        });
-    }
-    if (facts.container.indexPlacement === MediaIndexPlacement.End) {
-        conditions.push({
-            code: MediaConditionCode.IndexAtEnd,
-            detail: facts.remote
-                ? "The frame index sits after the media data, so opening this over a link fetches the end of the file before the first frame."
-                : "The frame index sits after the media data, which costs nothing to read from bytes already on this machine.",
-            frameEffect: ConversionFrameEffect.Preserved,
-            response: facts.remote
-                ? MediaConditionResponse.RemuxFirst
-                : MediaConditionResponse.None,
-            scope: MediaConditionScope.Playback,
-        });
-    }
-    if (facts.container.indexPlacement === MediaIndexPlacement.Fragmented) {
-        conditions.push({
-            code: MediaConditionCode.IndexFragmented,
-            detail: "The file carries one index per fragment rather than one for the whole, so a seek resolves against the fragment it lands in.",
-            frameEffect: ConversionFrameEffect.Preserved,
-            response: MediaConditionResponse.None,
-            scope: MediaConditionScope.Playback,
-        });
-    }
-    if (facts.timing) {
-        conditions.push(...timingConditions(facts.timing));
-    }
-    return createReport(facts, conditions);
-}
-/**
- * What a conversion would do to the frame sequence, judged against the options
- * as {@link normalizeMedia} will actually run them rather than as they were
- * written: leaving the rate unstated does not keep the source's timing here,
- * it takes the 30 hertz default.
- *
- * A stated rate is only safe on a source that already runs at exactly that
- * rate. On anything else the conversion writes a different number of pictures
- * at different times, and a detection carrying a source frame index then names
- * a picture that was never at that position.
- */
-function describeConversionFrameEffect(options) {
-    const resolvedFrameRate = options.video?.frameRate ?? DEFAULT_NORMALIZATION_FRAME_RATE;
-    const timing = options.timing ?? null;
-    if (!timing) {
-        return {
-            detail: `The conversion writes ${resolvedFrameRate} frames a second and nothing measured what the source runs at, so whether the frames survive is unknown and has to be assumed not to.`,
-            effect: ConversionFrameEffect.Resampled,
-            resolvedFrameRate,
-        };
-    }
-    if (distinctGapsExceedTimebaseRounding(timing)) {
-        return {
-            detail: `The source's frames do not arrive on a steady grid, so writing them out at ${resolvedFrameRate} a second drops and repeats pictures to fill it.`,
-            effect: ConversionFrameEffect.Resampled,
-            resolvedFrameRate,
-        };
-    }
-    if (timing.medianGapTicks === 0) {
-        return {
-            detail: `The source holds one frame, and a conversion at ${resolvedFrameRate} frames a second writes as many of it as the output's duration asks for.`,
-            effect: ConversionFrameEffect.Resampled,
-            resolvedFrameRate,
-        };
-    }
-    const sourceFrameRate = timing.tickRate / timing.medianGapTicks;
-    if (!ratesMatch(sourceFrameRate, resolvedFrameRate)) {
-        return {
-            detail: `The source runs at ${sourceFrameRate.toFixed(3)} frames a second and the conversion writes ${resolvedFrameRate}, so the output carries a different picture at every position.`,
-            effect: ConversionFrameEffect.Resampled,
-            resolvedFrameRate,
-        };
-    }
-    return {
-        detail: `The conversion writes the rate the source already runs at, so each source frame comes out once and a source frame index still names the picture it named.`,
-        effect: ConversionFrameEffect.Preserved,
-        resolvedFrameRate,
-    };
-}
-function timingConditions(timing) {
-    const conditions = [];
-    if (distinctGapsExceedTimebaseRounding(timing)) {
-        conditions.push({
-            code: MediaConditionCode.UnstableFrameTiming,
-            detail: unstableTimingDetail(timing),
-            frameEffect: null,
-            response: MediaConditionResponse.Refuse,
-            scope: MediaConditionScope.FrameIndexing,
-        });
-    }
-    if (timing.firstTimestampTicks !== 0) {
-        conditions.push({
-            code: MediaConditionCode.NonZeroStart,
-            detail: `The first frame is presented at ${(timing.firstTimestampTicks / timing.tickRate).toFixed(3)} seconds, so media time and elapsed time differ by that much on this source.`,
-            frameEffect: ConversionFrameEffect.Preserved,
-            response: MediaConditionResponse.None,
-            scope: MediaConditionScope.FrameIndexing,
-        });
-    }
-    return conditions;
-}
-function unstableTimingDetail(timing) {
-    const scope = timing.sampleComplete
-        ? `across all ${timing.sampledPacketCount} frames`
-        : `across the first ${timing.sampledPacketCount} frames`;
-    return timing.duplicateTimestampCount > 0
-        ? `${timing.duplicateTimestampCount} pair(s) of frames share one presentation timestamp ${scope}, so no arithmetic can tell those pictures apart by time.`
-        : `Neighbouring frames are separated by ${timing.distinctGapCount} different gaps ${scope}, from ${timing.minGapTicks} to ${timing.maxGapTicks} ticks of ${timing.tickRate}, which is more than a timebase's own rounding produces.`;
-}
-/**
- * Whether the gaps between frames take more values than a timebase that cannot
- * state the rate exactly would produce on its own. Duplicate timestamps are
- * counted here too: they are a zero gap, and a zero gap is never rounding.
- */
-function distinctGapsExceedTimebaseRounding(timing) {
-    return (timing.duplicateTimestampCount > 0 ||
-        timing.distinctGapCount > MAX_STABLE_DISTINCT_GAPS);
-}
-/**
- * A rate derived from a median gap of whole ticks lands within a tick of the
- * rate it stands for, so `30000/1001` read off a 90000-tick grain is 29.97003
- * and the 29.97 a caller writes has to match it.
- */
-function ratesMatch(sourceFrameRate, requestedFrameRate) {
-    return Math.abs(sourceFrameRate - requestedFrameRate) < 0.01;
-}
-function createReport(facts, conditions) {
-    return {
-        conditions,
-        facts,
-        frameIndexing: strongestResponse(conditions, MediaConditionScope.FrameIndexing),
-        playback: strongestResponse(conditions, MediaConditionScope.Playback),
-    };
-}
-function strongestResponse(conditions, scope) {
-    let strongest = MediaConditionResponse.None;
-    for (const condition of conditions) {
-        if (condition.scope === scope &&
-            RESPONSE_STRENGTH[condition.response] > RESPONSE_STRENGTH[strongest]) {
-            strongest = condition.response;
-        }
-    }
-    return strongest;
-}
-
-const DEFAULT_SAMPLE_PACKETS = 240;
-/** Enough for a 64-bit box header, which is the longest one this walk reads. */
-const BOX_HEADER_BYTES = 16;
-const BOX_HEADER_MINIMUM_BYTES = 8;
-const LARGE_SIZE_MARKER = 1;
-/** A file whose top-level boxes have not resolved the question by here is not
- *  laid out in a way this walk describes. */
-const MAX_TOP_LEVEL_BOXES = 12;
-/**
- * Measures a source once and says which conversion conditions hold.
- *
- * Deliberately cheap, because "convert only when necessary" is worth nothing if
- * finding out costs what converting would. Nothing here decodes a frame or
- * reads a byte of media data on an indexed container: the container's own box
- * headers answer where the index sits, and the packet walk runs metadata-only
- * over a bounded prefix.
- */
-async function probeMediaConditions(source, options = {}) {
-    const { ALL_FORMATS, BlobSource, Input, UnsupportedInputFormatError } = await import('mediabunny');
-    const indexPlacement = await readIndexPlacement((start, end) => source.slice(start, end).arrayBuffer().then(toBytes), source.size);
-    const input = new Input({
-        formats: ALL_FORMATS,
-        source: new BlobSource(source),
-    });
-    try {
-        const facts = await collectFacts({
-            indexPlacement,
-            input,
-            remote: options.remote === true,
-            samplePackets: options.samplePackets ?? DEFAULT_SAMPLE_PACKETS,
-            UnsupportedInputFormatError,
-        });
-        return evaluateMediaConditions(facts, options);
-    }
-    finally {
-        input.dispose();
-    }
-}
-/**
- * Where an ISO base media file keeps its frame index, read from the top-level
- * box headers alone.
- *
- * Each header states the size of its own box, so the walk hops from one to the
- * next and never reads a box's contents: eight to sixteen bytes per box, and no
- * more boxes than it takes to see `moov` or `moof`. Over a link that is a
- * handful of range requests whatever the file weighs.
- */
-async function readIndexPlacement(read, size) {
-    let offset = 0;
-    let sawIndex = false;
-    let sawMediaData = false;
-    for (let box = 0; box < MAX_TOP_LEVEL_BOXES; box += 1) {
-        const end = Math.min(offset + BOX_HEADER_BYTES, size);
-        if (end - offset < BOX_HEADER_MINIMUM_BYTES) {
-            return MediaIndexPlacement.Unknown;
-        }
-        const header = await read(offset, end);
-        if (header.byteLength < BOX_HEADER_MINIMUM_BYTES) {
-            return MediaIndexPlacement.Unknown;
-        }
-        const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
-        const type = boxType(header);
-        if (box === 0 && type !== "ftyp") {
-            return MediaIndexPlacement.Unknown;
-        }
-        if (type === "moof") {
-            return MediaIndexPlacement.Fragmented;
-        }
-        if (type === "moov") {
-            if (sawMediaData) {
-                return MediaIndexPlacement.End;
-            }
-            // A fragmented file opens on an index too, and only the fragment header
-            // that follows it tells the two layouts apart.
-            sawIndex = true;
-        }
-        if (type === "mdat") {
-            if (sawIndex) {
-                return MediaIndexPlacement.Front;
-            }
-            sawMediaData = true;
-        }
-        const boxSize = readBoxSize(view, header.byteLength);
-        if (boxSize === null) {
-            return MediaIndexPlacement.Unknown;
-        }
-        offset += boxSize;
-        if (offset >= size) {
-            return MediaIndexPlacement.Unknown;
-        }
-    }
-    return MediaIndexPlacement.Unknown;
-}
-async function collectFacts(options) {
-    let videoTrack;
-    try {
-        videoTrack = await options.input.getPrimaryVideoTrack();
-    }
-    catch (error) {
-        if (error instanceof options.UnsupportedInputFormatError) {
-            return {
-                canDecode: null,
-                codec: null,
-                container: null,
-                remote: options.remote,
-                timing: null,
-                trackCount: 0,
-                videoTrackCount: 0,
-            };
-        }
-        throw error;
-    }
-    const tracks = await options.input.getTracks();
-    const container = { indexPlacement: options.indexPlacement };
-    if (!videoTrack) {
-        return {
-            canDecode: null,
-            codec: null,
-            container,
-            remote: options.remote,
-            timing: null,
-            trackCount: tracks.length,
-            videoTrackCount: 0,
-        };
-    }
-    const [codec, canDecode] = await Promise.all([
-        videoTrack.getCodec(),
-        videoTrack.canDecode(),
-    ]);
-    return {
-        canDecode,
-        codec,
-        container,
-        remote: options.remote,
-        timing: await measureTiming(videoTrack, options.samplePackets),
-        trackCount: tracks.length,
-        videoTrackCount: countVideoTracks(tracks),
-    };
-}
-async function measureTiming(videoTrack, samplePackets) {
-    const { EncodedPacketSink } = await import('mediabunny');
-    const tickRate = await readTickRate(videoTrack);
-    const sink = new EncodedPacketSink(videoTrack);
-    const decodeOrderTicks = [];
-    let sampleComplete = true;
-    for await (const packet of sink.packets(undefined, undefined, {
-        metadataOnly: true,
-    })) {
-        decodeOrderTicks.push(Math.round(packet.timestamp * tickRate));
-        if (decodeOrderTicks.length >= samplePackets) {
-            sampleComplete = false;
-            break;
-        }
-    }
-    return summarizeTiming(decodeOrderTicks, tickRate, sampleComplete);
-}
-/**
- * Turns a walk of packet timestamps into the timing facts, in ticks.
- *
- * Decode order is not presentation order, so the table is sorted before its
- * gaps are read. A walk that stopped at the cap has read every packet up to a
- * decode position and no further, which leaves the tail of the sorted table
- * missing frames that sit between ones it did read; the deepest reordering seen
- * bounds how much of that tail is untrustworthy, and it is dropped. A walk that
- * ran to the end of the track has no such tail.
- */
-function summarizeTiming(decodeOrderTicks, tickRate, sampleComplete) {
-    const sorted = [...decodeOrderTicks].sort((first, second) => first - second);
-    const usable = sampleComplete
-        ? sorted
-        : sorted.slice(0, Math.max(2, sorted.length - reorderDepth(sorted, decodeOrderTicks)));
-    const gaps = [];
-    for (let index = 1; index < usable.length; index += 1) {
-        gaps.push(usable[index] - usable[index - 1]);
-    }
-    gaps.sort((first, second) => first - second);
-    return {
-        distinctGapCount: new Set(gaps).size,
-        duplicateTimestampCount: gaps.filter((gap) => gap === 0).length,
-        firstTimestampTicks: sorted.length > 0 ? sorted[0] : 0,
-        maxGapTicks: gaps.length > 0 ? gaps[gaps.length - 1] : 0,
-        medianGapTicks: gaps.length > 0 ? gaps[gaps.length >> 1] : 0,
-        minGapTicks: gaps.length > 0 ? gaps[0] : 0,
-        sampleComplete,
-        sampledPacketCount: decodeOrderTicks.length,
-        tickRate,
-    };
-}
-/** How far a packet travels between decode position and presentation position,
- *  at its furthest. */
-function reorderDepth(sorted, decodeOrderTicks) {
-    const rankByTick = new Map();
-    for (let index = 0; index < sorted.length; index += 1) {
-        if (!rankByTick.has(sorted[index])) {
-            rankByTick.set(sorted[index], index);
-        }
-    }
-    let deepest = 0;
-    for (let index = 0; index < decodeOrderTicks.length; index += 1) {
-        const rank = rankByTick.get(decodeOrderTicks[index]) ?? index;
-        deepest = Math.max(deepest, Math.abs(rank - index));
-    }
-    return deepest;
-}
-async function readTickRate(videoTrack) {
-    return typeof videoTrack.getTimeResolution === "function"
-        ? await videoTrack.getTimeResolution()
-        : (videoTrack.timeResolution ?? 1);
-}
-function countVideoTracks(tracks) {
-    return tracks.filter((track) => {
-        return track.type === "video";
-    }).length;
-}
-function boxType(header) {
-    return String.fromCharCode(header[4], header[5], header[6], header[7]);
-}
-function readBoxSize(view, available) {
-    const size = view.getUint32(0);
-    if (size === LARGE_SIZE_MARKER) {
-        return available < BOX_HEADER_BYTES
-            ? null
-            : Number(view.getBigUint64(BOX_HEADER_MINIMUM_BYTES));
-    }
-    return size < BOX_HEADER_MINIMUM_BYTES ? null : size;
-}
-function toBytes(buffer) {
-    return new Uint8Array(buffer);
-}
-
 /** Creates an image-first renderer source without routing through Mediabunny. */
 function createStaticImageMediaSource(source) {
     return {
@@ -2301,7 +1694,7 @@ function createImageUrlMediaSource(src, options = {}) {
     return createStaticImageMediaSource(image);
 }
 function createSingleFrameSource(source, width, height) {
-    const sample = createSample$1(source, width, height);
+    const sample = createSample(source, width, height);
     const sampleSink = {
         async getSample() {
             return sample;
@@ -2328,7 +1721,7 @@ function createSingleFrameSource(source, width, height) {
         sampleSink,
     };
 }
-function createSample$1(source, width, height) {
+function createSample(source, width, height) {
     return {
         close() { },
         draw(context, dx, dy, dWidth = width, dHeight = height) {
@@ -2370,8 +1763,8 @@ async function waitForImage(image) {
 }
 
 const DEFAULT_MAX_BUFFERED_FRAMES = 8;
-const DEFAULT_FRAME_RATE$2 = 30;
-const TIMESTAMP_EPSILON_SECONDS$1 = 1e-6;
+const DEFAULT_FRAME_RATE$1 = 30;
+const TIMESTAMP_EPSILON_SECONDS = 1e-6;
 /**
  * Adapts a browser MediaStream to the renderer-owned decoded-media boundary.
  *
@@ -2402,7 +1795,7 @@ async function openMediaStreamMediaSource(stream, options) {
     video.muted = true;
     video.playsInline = true;
     video.srcObject = stream;
-    const fallbackFrameDuration = resolveFrameDuration$1(videoTracks[0]);
+    const fallbackFrameDuration = resolveFrameDuration(videoTracks[0]);
     const bufferedFrames = [];
     const waiters = new Set();
     let disposed = false;
@@ -2469,7 +1862,7 @@ async function openMediaStreamMediaSource(stream, options) {
             frame.image.close();
             return;
         }
-        if (frame.timestamp <= lastCapturedTimestamp + TIMESTAMP_EPSILON_SECONDS$1) {
+        if (frame.timestamp <= lastCapturedTimestamp + TIMESTAMP_EPSILON_SECONDS) {
             frame.image.close();
             return;
         }
@@ -2554,7 +1947,7 @@ async function openMediaStreamMediaSource(stream, options) {
     const takeFrame = (startTimestamp, preferLatest) => {
         const minimumTimestamp = startTimestamp ?? Number.NEGATIVE_INFINITY;
         while (bufferedFrames[0] &&
-            bufferedFrames[0].timestamp < minimumTimestamp - TIMESTAMP_EPSILON_SECONDS$1) {
+            bufferedFrames[0].timestamp < minimumTimestamp - TIMESTAMP_EPSILON_SECONDS) {
             bufferedFrames.shift()?.image.close();
         }
         if (bufferedFrames.length === 0)
@@ -2593,7 +1986,7 @@ async function openMediaStreamMediaSource(stream, options) {
                 const frame = await nextFrame(startTimestamp);
                 if (!frame)
                     return;
-                startTimestamp = frame.timestamp + TIMESTAMP_EPSILON_SECONDS$1;
+                startTimestamp = frame.timestamp + TIMESTAMP_EPSILON_SECONDS;
                 yield createDecodedSample(frame);
             }
         },
@@ -2697,304 +2090,10 @@ function resolveMaxBufferedFrames(value) {
     }
     return value;
 }
-function resolveFrameDuration$1(track) {
+function resolveFrameDuration(track) {
     const frameRate = track?.getSettings?.().frameRate;
     return frameRate && Number.isFinite(frameRate) && frameRate > 0
         ? 1 / frameRate
-        : 1 / DEFAULT_FRAME_RATE$2;
-}
-
-const DEFAULT_MAX_DEVICE_PIXEL_RATIO = 2;
-/**
- * The pixel ratio a host's display box rasterizes at, for every grid that lands
- * in that box: the presentation surface, the mask rasters drawn onto it, and the
- * decode under both. The ceiling is what keeps a 3x display from costing nine
- * times the texels of a 1x one for sharpness nobody resolves on a moving
- * picture. An id raster carries a detection per pixel and can only be sampled
- * nearest, so a grid it does not share ragged its edges.
- *
- * A ceiling that is not a usable number states nothing, and takes the default.
- */
-function resolveDisplayPixelRatio(display) {
-    const { devicePixelRatio, maxDevicePixelRatio } = display;
-    if (!Number.isFinite(devicePixelRatio) || devicePixelRatio <= 0) {
-        return 1;
-    }
-    const ceiling = maxDevicePixelRatio !== undefined &&
-        Number.isFinite(maxDevicePixelRatio) &&
-        maxDevicePixelRatio > 0
-        ? maxDevicePixelRatio
-        : DEFAULT_MAX_DEVICE_PIXEL_RATIO;
-    return Math.min(devicePixelRatio, ceiling);
-}
-
-const VIDEO_ENGINE_ENTRY = "supervision/web-video-engine";
-const VIDEO_ENGINE_ANALYSIS_ENTRY = `${VIDEO_ENGINE_ENTRY}/analysis`;
-/**
- * A bundler renames the engine chunk after the module it was split from, and a
- * browser reports the failing chunk's URL rather than the specifier that asked
- * for it, so the name a failure can be recognised by is the module's, not the
- * entry's.
- */
-const VIDEO_ENGINE_MODULE = "web-video-engine";
-const MISSING_MODULE_ERROR_CODES = new Set([
-    "ERR_MODULE_NOT_FOUND",
-    "MODULE_NOT_FOUND",
-]);
-const MISSING_MODULE_MESSAGE = /cannot find (?:module|package)|failed to (?:resolve|fetch dynamically imported) module|could not resolve/i;
-const QUOTED_SPECIFIER = /['"]([^'"]+)['"]/;
-const MAX_WRAPPED_ERROR_DEPTH = 8;
-/**
- * The engine is a chunk of this package that the browser fetches on demand, so
- * the raw failure names a URL nobody wrote and reads like a bug in the caller's
- * own code.
- */
-function rethrowEngineImportFailure(error, entry) {
-    if (isEngineResolutionFailure(error)) {
-        throw new Error(`openVideoEngineMediaSource needs "${entry}", which did not load. ` +
-            "The video engine is a lazily loaded chunk of supervision, so check " +
-            "that the deployed build still serves every chunk it emitted.", { cause: error });
-    }
-    throw error;
-}
-/**
- * An engine that never loaded and an engine that loaded and then threw arrive
- * at the same catch, and only the first is a deployment problem. Loaders that
- * wrap what they caught put the load failure under the error they raise, so the
- * whole cause chain is read, bounded because a chain can be cyclic.
- */
-function isEngineResolutionFailure(error) {
-    let cursor = error;
-    for (let depth = 0; depth <= MAX_WRAPPED_ERROR_DEPTH; depth += 1) {
-        if (!(cursor instanceof Error))
-            return false;
-        if (namesUnloadableEngine(cursor))
-            return true;
-        cursor = cursor.cause;
-    }
-    return false;
-}
-/**
- * Node and bundlers quote the specifier they failed to resolve, so a dependency
- * missing from an engine that did load is told apart by whose name is quoted; a
- * browser reports an unquoted URL, which carries the chunk name too.
- *
- * Each bundler words this differently and one of them stubs the import with an
- * error of its own, so the wording is matched as well as the code. A build that
- * names the engine first and its importer second is the engine failing to load;
- * one that names a dependency first is that dependency's problem, and reading
- * only the first quoted specifier keeps the two apart.
- */
-function namesUnloadableEngine(error) {
-    const code = "code" in error ? String(error.code) : "";
-    if (!MISSING_MODULE_ERROR_CODES.has(code) &&
-        !MISSING_MODULE_MESSAGE.test(error.message)) {
-        return false;
-    }
-    const quoted = QUOTED_SPECIFIER.exec(error.message)?.[1];
-    return (quoted ?? error.message).includes(VIDEO_ENGINE_MODULE);
-}
-
-const MILLISECONDS_PER_SECOND$2 = 1000;
-const DEFAULT_FRAME_RATE$1 = 30;
-const TIMESTAMP_EPSILON_SECONDS = 1e-6;
-const FRAMES_PRESENTATION_PREVIEW_MAX_WIDTH_PX = 320;
-/**
- * Adapts Roboflow's video engine to the decoded-media source seam.
- *
- * The pull path, `sampleSink`, serves one-off reads such as thumbnails and
- * single frame grabs, decoding each request from scratch through the engine's
- * batch analysis entry. The push path serves playback and scrub presentation:
- * the engine holds no canvas, paints nothing, and announces every frame that
- * earns the screen, so a compositor subscribes to `engine` and never pulls
- * samples here.
- */
-async function openVideoEngineMediaSource(options) {
-    const { VideoEngine, displayBoxResolution } = await importEngineEntry();
-    const { display, frameDecodeStrategy, ...engineOptions } = options;
-    const engine = new VideoEngine({
-        decodeStrategy: display ? displayBoxResolution(display) : undefined,
-        previewWidth: framesPreviewWidth(display),
-        ...engineOptions,
-        presentation: "frames",
-    });
-    try {
-        const snapshot = await engine.load();
-        const frames = createAnalysisFrameReader({
-            decodeStrategy: frameDecodeStrategy,
-            frameDuration: resolveFrameDuration(snapshot.nativeFps),
-            source: options.source,
-        });
-        return {
-            engine,
-            input: {
-                dispose() {
-                    void frames.close();
-                    void engine.dispose();
-                },
-            },
-            metadata: createMetadata(options.source, snapshot),
-            sampleSink: frames.sampleSink,
-        };
-    }
-    catch (error) {
-        await engine.dispose();
-        throw error;
-    }
-}
-function createVideoEngineMediaRendererSource(options) {
-    return {
-        open() {
-            return openVideoEngineMediaSource(options);
-        },
-    };
-}
-/**
- * The engine ships inside this package, and arrives through a dynamic import so
- * that it lands in its own chunk: a consumer who only annotates images never
- * downloads the engine's embedded decode worker. A static import would fold it
- * into the main entry.
- */
-async function importEngineEntry() {
-    try {
-        return await import('./web-video-engine/engine.js');
-    }
-    catch (error) {
-        rethrowEngineImportFailure(error, VIDEO_ENGINE_ENTRY);
-    }
-}
-async function importAnalysisEntry() {
-    try {
-        return await import('./web-video-engine/analysis.js');
-    }
-    catch (error) {
-        rethrowEngineImportFailure(error, VIDEO_ENGINE_ANALYSIS_ENTRY);
-    }
-}
-/**
- * A wider coarse frame means fewer of them resident, and residency is what a
- * drag spends: a scrub position holding no coarse frame paints nothing until a
- * full decode returns. A stated box only ever lowers the width, since a preview
- * wider than the picture it stands in for buys no sharpness and costs resident
- * frames.
- */
-function framesPreviewWidth(display) {
-    if (display === undefined || !(display.boxWidth > 0)) {
-        return FRAMES_PRESENTATION_PREVIEW_MAX_WIDTH_PX;
-    }
-    return Math.min(FRAMES_PRESENTATION_PREVIEW_MAX_WIDTH_PX, Math.ceil(display.boxWidth * resolveDisplayPixelRatio(display)));
-}
-function createAnalysisFrameReader(options) {
-    let sessionPromise;
-    let closed = false;
-    const openSession = () => {
-        sessionPromise ??= (async () => {
-            const { AnalysisSession } = await importAnalysisEntry();
-            return AnalysisSession.open({
-                decodeStrategy: options.decodeStrategy,
-                source: options.source,
-            });
-        })();
-        return sessionPromise;
-    };
-    const extractAt = async (timestamp) => {
-        if (closed)
-            return null;
-        const session = await openSession();
-        const [frame] = await session.extractFrames([timestamp]);
-        return frame ?? null;
-    };
-    const sampleSink = {
-        async getSample(timestamp) {
-            const frame = await extractAt(timestamp);
-            return frame ? createSample(frame, options.frameDuration) : null;
-        },
-        async *samples(startTimestamp = 0, endTimestamp = Number.POSITIVE_INFINITY) {
-            let cursor = startTimestamp;
-            let lastTimestamp = Number.NEGATIVE_INFINITY;
-            while (cursor <= endTimestamp) {
-                const frame = await extractAt(cursor);
-                if (!frame)
-                    return;
-                // The analysis entry answers with the frame on screen at the requested
-                // timestamp, so a request past the last frame answers with that frame
-                // again. A timestamp that does not advance is the end of the track.
-                if (frame.timestampS <= lastTimestamp + TIMESTAMP_EPSILON_SECONDS) {
-                    return;
-                }
-                lastTimestamp = frame.timestampS;
-                cursor = Math.max(cursor, frame.timestampS) + options.frameDuration;
-                yield createSample(frame, options.frameDuration);
-            }
-        },
-        async *samplesAtTimestamps(timestamps) {
-            if (closed)
-                return;
-            const session = await openSession();
-            for await (const frame of session.framesAtTimestamps([...timestamps])) {
-                yield frame ? createSample(frame, options.frameDuration) : null;
-            }
-        },
-    };
-    const close = async () => {
-        closed = true;
-        const opening = sessionPromise;
-        sessionPromise = undefined;
-        if (!opening)
-            return;
-        try {
-            const session = await opening;
-            await session.close();
-        }
-        catch {
-            // A session that failed to open already rejected the pull that opened it.
-        }
-    };
-    return { close, sampleSink };
-}
-function createSample(frame, duration) {
-    let closed = false;
-    return {
-        close() {
-            closed = true;
-        },
-        draw(context, dx, dy, dWidth = frame.width, dHeight = frame.height) {
-            if (closed)
-                throw new Error("Cannot draw a closed video engine frame.");
-            context.drawImage(frame.canvas, dx, dy, dWidth, dHeight);
-        },
-        duration,
-        timestamp: frame.timestampS,
-    };
-}
-function createMetadata(source, snapshot) {
-    const duration = Number.isFinite(snapshot.durationMs)
-        ? snapshot.durationMs / MILLISECONDS_PER_SECOND$2
-        : null;
-    const estimatedFrameRate = snapshot.nativeFps !== null && snapshot.nativeFps > 0
-        ? snapshot.nativeFps
-        : null;
-    return {
-        audioTrackCount: 0,
-        canRead: snapshot.canDecode,
-        duration,
-        estimatedFrameCount: duration !== null && estimatedFrameRate !== null
-            ? Math.max(1, Math.round(duration * estimatedFrameRate))
-            : null,
-        estimatedFrameRate,
-        firstTimestamp: snapshot.firstTimestampMs / MILLISECONDS_PER_SECOND$2,
-        formatMimeType: null,
-        formatName: "video-engine",
-        mimeType: "stream" in source ? source.mimeType : null,
-        primaryVideoHeight: snapshot.naturalHeight,
-        primaryVideoWidth: snapshot.naturalWidth,
-        trackCount: 1,
-        videoTrackCount: 1,
-    };
-}
-function resolveFrameDuration(nativeFps) {
-    return nativeFps !== null && nativeFps > 0
-        ? 1 / nativeFps
         : 1 / DEFAULT_FRAME_RATE$1;
 }
 
@@ -3025,6 +2124,9 @@ var RenderEnginePreference;
     RenderEnginePreference["WebGL"] = "webgl";
 })(RenderEnginePreference || (RenderEnginePreference = {}));
 const ALREADY_PRESENTED_SAMPLE_EPSILON_SECONDS = 1e-6;
+const DEFAULT_RENDER_PREPARATION_GATE_MAX_WAIT_SECONDS = 2;
+const DEFAULT_RENDER_PREPARATION_GATE_RESUME_MARGIN_WALL_SECONDS = 0.2;
+const DEFAULT_RENDER_PREPARATION_GATE_STOP_BELOW_WALL_SECONDS = 0.1;
 const RENDER_ENGINE_PREFERENCE = RenderEnginePreference.WebGL;
 
 const PLAYBACK_SAMPLE_QUEUE_CAPACITY = 6;
@@ -3042,6 +2144,7 @@ function createMediaPlaybackController(options) {
     let activeSampleIteratorId = 0;
     let activePrefetch;
     let activeSampleIteratorExhausted = false;
+    let activeSampleWait;
     const queuedSampleWaiters = new Set();
     const notifyQueuedSampleWaiters = () => {
         for (const resolve of queuedSampleWaiters)
@@ -3055,6 +2158,16 @@ function createMediaPlaybackController(options) {
         }
     };
     const isPlaybackRunActive = (runId) => !destroyed && playing && playbackRunId === runId;
+    /**
+     * Starts the run that supersedes every earlier one. A readiness wait is
+     * awaited bare, so this is the only moment anything knows the sample it was
+     * started for will never be presented, and the only chance to say so.
+     */
+    const beginPlaybackRun = () => {
+        activeSampleWait?.abort();
+        activeSampleWait = undefined;
+        playbackRunId += 1;
+    };
     const schedulePlaybackFrame = (runId) => {
         if (!isPlaybackRunActive(runId) || animationFrameHandle !== undefined) {
             return;
@@ -3105,7 +2218,7 @@ function createMediaPlaybackController(options) {
             return;
         }
         playing = false;
-        playbackRunId += 1;
+        beginPlaybackRun();
         cancelScheduledFrame();
         closeQueuedSamples();
         stopActiveSampleIterator();
@@ -3183,10 +2296,16 @@ function createMediaPlaybackController(options) {
                 queuedSampleWaiters.delete(resolveWait);
             return;
         }
-        await waitForQueuedSample;
-        // Let an iterator publish immediately available adjacent samples without
-        // making live playback wait for the next network frame.
-        await Promise.resolve();
+        options.onSourceWait?.(true);
+        try {
+            await waitForQueuedSample;
+            // Let an iterator publish immediately available adjacent samples without
+            // making live playback wait for the next network frame.
+            await Promise.resolve();
+        }
+        finally {
+            options.onSourceWait?.(false);
+        }
     };
     const shouldPresentSample = (sample, shouldPresentLoopStartSample) => sample.timestamp > currentTime + ALREADY_PRESENTED_SAMPLE_EPSILON_SECONDS ||
         (shouldPresentLoopStartSample &&
@@ -3227,7 +2346,7 @@ function createMediaPlaybackController(options) {
         if (playableEnd !== null && requestedMediaTime >= playableEnd) {
             if (!options.loop) {
                 playing = false;
-                playbackRunId += 1;
+                beginPlaybackRun();
                 closeQueuedSamples();
                 stopActiveSampleIterator();
                 options.onEnded();
@@ -3261,7 +2380,7 @@ function createMediaPlaybackController(options) {
             }
             if (activeSampleIteratorExhausted && sampleQueue.length === 0) {
                 playing = false;
-                playbackRunId += 1;
+                beginPlaybackRun();
                 stopActiveSampleIterator();
                 options.onEnded();
                 return;
@@ -3302,11 +2421,16 @@ function createMediaPlaybackController(options) {
             didNotifyWaiting = true;
             options.onWaiting?.();
         }, 0);
+        const sampleWait = new AbortController();
+        activeSampleWait = sampleWait;
         try {
-            await options.waitForSample(sample);
+            await options.waitForSample(sample, sampleWait.signal);
         }
         finally {
             clearTimeout(waitingTimer);
+            if (activeSampleWait === sampleWait) {
+                activeSampleWait = undefined;
+            }
         }
         if (!didNotifyWaiting) {
             return false;
@@ -3320,7 +2444,7 @@ function createMediaPlaybackController(options) {
                 return;
             }
             playing = true;
-            playbackRunId += 1;
+            beginPlaybackRun();
             playbackOriginMediaTime = currentTime;
             playbackOriginNow = performance.now();
             resetSampleIterator(currentTime);
@@ -3332,7 +2456,7 @@ function createMediaPlaybackController(options) {
                 return;
             }
             playing = false;
-            playbackRunId += 1;
+            beginPlaybackRun();
             cancelScheduledFrame();
             closeQueuedSamples();
             stopActiveSampleIterator();
@@ -3343,7 +2467,7 @@ function createMediaPlaybackController(options) {
             }
             const shouldResume = playing;
             playing = false;
-            playbackRunId += 1;
+            beginPlaybackRun();
             cancelScheduledFrame();
             closeQueuedSamples();
             stopActiveSampleIterator();
@@ -3354,7 +2478,7 @@ function createMediaPlaybackController(options) {
                 return;
             }
             playing = true;
-            playbackRunId += 1;
+            beginPlaybackRun();
             resetSampleIterator(mediaTime);
             startSamplePrefetch(playbackRunId);
             schedulePlaybackFrame(playbackRunId);
@@ -3379,7 +2503,7 @@ function createMediaPlaybackController(options) {
             }
             destroyed = true;
             playing = false;
-            playbackRunId += 1;
+            beginPlaybackRun();
             cancelScheduledFrame();
             closeQueuedSamples();
             stopActiveSampleIterator();
@@ -3537,6 +2661,7 @@ function createOffsetDetectionFrameSource(source, offsetSeconds) {
 function createLoadingMediaSourceState() {
     return {
         audioTrackCount: null,
+        awaitingRead: false,
         canRead: null,
         duration: null,
         estimatedFrameCount: null,
@@ -3557,6 +2682,7 @@ function createLoadingMediaSourceState() {
 function createReadyMediaSourceState(metadata) {
     return {
         audioTrackCount: metadata.audioTrackCount,
+        awaitingRead: false,
         canRead: metadata.canRead,
         duration: metadata.duration,
         estimatedFrameCount: metadata.estimatedFrameCount ?? null,
@@ -3589,12 +2715,14 @@ function createMediaRendererRuntimeState(options) {
     let rendererBackend = null;
     /** Frames put on screen, not paints. */
     let presentedFrames = 0;
+    let presentedTime = null;
     let presentedFrameSerial = 0;
     let activeDetectionFrameTime = null;
     let activeDetectionFrameIndex = null;
     let activeDetectionCount = 0;
     let drawnMaskFrameTime = null;
     let maskHeldStale = false;
+    let renderPreparationGateAbandoned = false;
     let seeking = false;
     let scrubbing = false;
     let lastFrameRenderTimings = null;
@@ -3627,6 +2755,8 @@ function createMediaRendererRuntimeState(options) {
         playbackGateReach: options.getPlaybackGateReach(),
         playbackState,
         presentedFrames,
+        presentedTime,
+        renderPreparationGateAbandoned,
         scrubbing,
         seeking,
         rendererBackend,
@@ -3653,8 +2783,11 @@ function createMediaRendererRuntimeState(options) {
     const emitState = () => {
         options.onState?.(createStateSnapshot());
     };
-    const adoptPresentedSample = (sample) => {
-        currentTime = sample.mediaTime;
+    const adoptPresentedSample = (sample, adoptCurrentTime) => {
+        if (adoptCurrentTime) {
+            currentTime = sample.mediaTime;
+        }
+        presentedTime = sample.mediaTime;
         activeDetectionFrameIndex = sample.activeDetectionFrameIndex;
         activeDetectionFrameTime = sample.activeDetectionFrameTime;
         activeDetectionCount = sample.activeDetectionCount;
@@ -3665,6 +2798,9 @@ function createMediaRendererRuntimeState(options) {
         currentTime() {
             return currentTime;
         },
+        presentedTime() {
+            return presentedTime;
+        },
         duration() {
             return duration;
         },
@@ -3701,6 +2837,23 @@ function createMediaRendererRuntimeState(options) {
             sourceState = createReadyMediaSourceState(metadata);
             emitSourceState();
         },
+        setSourceAwaitingRead(awaitingRead) {
+            if (sourceState.awaitingRead === awaitingRead) {
+                return;
+            }
+            setSourceState({ awaitingRead });
+            emitState();
+        },
+        setRenderPreparationGateAbandoned(abandoned) {
+            if (renderPreparationGateAbandoned === abandoned) {
+                return;
+            }
+            renderPreparationGateAbandoned = abandoned;
+            emitState();
+        },
+        playbackRate() {
+            return playbackRate;
+        },
         recordPlayheadTime(nextCurrentTime) {
             if (currentTime === nextCurrentTime) {
                 return;
@@ -3722,17 +2875,18 @@ function createMediaRendererRuntimeState(options) {
             currentFrameDuration = sample.duration ?? currentFrameDuration;
             presentedFrames += 1;
             presentedFrameSerial = sample.presentedFrameSerial;
-            adoptPresentedSample(sample);
+            adoptPresentedSample(sample, true);
             lastFrameRenderTimings = sample.renderTimings ?? null;
             options.onFrame?.(createFrameDiagnostics(sample));
             emitState();
         },
         recordPresentationUpdate(sample) {
-            if (sample.presentedFrameSerial !== presentedFrameSerial) {
+            const isNewPresentedFrame = sample.presentedFrameSerial !== presentedFrameSerial;
+            if (isNewPresentedFrame) {
                 presentedFrames += 1;
                 presentedFrameSerial = sample.presentedFrameSerial;
             }
-            adoptPresentedSample(sample);
+            adoptPresentedSample(sample, isNewPresentedFrame);
             lastFrameRenderTimings = sample.renderTimings ?? lastFrameRenderTimings;
             emitState();
         },
@@ -3805,7 +2959,7 @@ function createMediaRenderErrorSourcePatch(error) {
     };
 }
 
-const MILLISECONDS_PER_SECOND$1 = 1000;
+const MILLISECONDS_PER_SECOND$2 = 1000;
 /**
  * The renderer's playback surface over a producer that owns the playhead.
  * Seconds meet milliseconds here and nowhere else.
@@ -3827,7 +2981,23 @@ function createMediaRendererTransport(options) {
     let playbackIntent = 0;
     /** Intent a readiness wait belongs to, or null while none is running. */
     let readinessHoldIntent = null;
-    const isHoldingForReadiness = () => readinessHoldIntent === playbackIntent;
+    /** Whether a readiness hold still owes the producer its release. */
+    let readinessFreezeHeld = false;
+    let activeReadinessWait;
+    let presentationWait = 0;
+    let presentationHold = null;
+    const isHoldingForReadiness = () => readinessHoldIntent === playbackIntent ||
+        presentationHold?.intent === playbackIntent;
+    /**
+     * Supersedes every playback intent still in flight. A readiness wait is
+     * awaited bare, so this is the only moment the gate can be told the play it
+     * is holding open is over.
+     */
+    const beginPlaybackIntent = () => {
+        activeReadinessWait?.abort();
+        activeReadinessWait = undefined;
+        return ++playbackIntent;
+    };
     const publishSeekSignals = () => {
         options.onScrubbing(gestureInFlight);
         options.onSeeking(isSettling(channel.getStatus(), channel.getSeeking()));
@@ -3837,9 +3007,19 @@ function createMediaRendererTransport(options) {
             return;
         }
         gestureInFlight = false;
+        // The producer holds one freeze, so a drag that took it over from a
+        // readiness hold is releasing that hold's too.
+        readinessFreezeHeld = false;
         publishSeekSignals();
         await channel.endInteractiveSeek();
     };
+    const releaseReadinessFreeze = async () => {
+        if (!readinessFreezeHeld || gestureInFlight) {
+            return;
+        }
+        readinessFreezeHeld = false;
+        await channel.endInteractiveSeek();
+    };
     const publishPlaybackState = () => {
         const status = channel.getStatus();
         // A producer never loops itself, and its play() from ENDED restarts at the
@@ -3881,9 +3061,10 @@ function createMediaRendererTransport(options) {
      * uses, so a drag arriving mid-hold takes the hold over rather than fighting
      * it and the release it lands with is the one that resumes.
      */
-    const holdForReadiness = async (wait) => {
+    const holdForReadiness = async (wait, readinessWait) => {
         const intent = playbackIntent;
         readinessHoldIntent = intent;
+        readinessFreezeHeld = true;
         channel.beginInteractiveSeek();
         publishPlaybackState();
         try {
@@ -3894,12 +3075,18 @@ function createMediaRendererTransport(options) {
             // that starts the producer again. Whoever owns the failure reports it.
         }
         finally {
+            if (activeReadinessWait === readinessWait) {
+                activeReadinessWait = undefined;
+            }
             if (readinessHoldIntent === intent) {
                 readinessHoldIntent = null;
             }
         }
-        if (!gestureInFlight) {
-            await channel.endInteractiveSeek();
+        // A play that superseded this hold is waiting for readiness of its own,
+        // and the producer running before that lands is what the wait is there to
+        // prevent. It inherits the freeze and releases it when it starts playback.
+        if (readinessHoldIntent === null) {
+            await releaseReadinessFreeze();
         }
         publishPlaybackState();
     };
@@ -3912,9 +3099,11 @@ function createMediaRendererTransport(options) {
             channel.getSeeking()) {
             return;
         }
-        const wait = options.holdForReadiness(channel.getPlayhead().mediaTimeS);
+        const readinessWait = new AbortController();
+        const wait = options.holdForReadiness(channel.getPlayhead().mediaTimeS, readinessWait.signal);
         if (wait) {
-            void holdForReadiness(wait);
+            activeReadinessWait = readinessWait;
+            void holdForReadiness(wait, readinessWait);
         }
     };
     const publishPlaybackRate = () => {
@@ -3928,39 +3117,66 @@ function createMediaRendererTransport(options) {
     ];
     const transport = {
         async play() {
+            options.invalidatePresentedFrame?.();
+            presentationWait += 1;
+            presentationHold = null;
             // The producer answers on its own thread, so its status still reads the
             // previous playback until it does. Recording the ask here is what lets a
             // second toggle arriving in that window flip it.
             settledState = MediaRendererPlaybackState.Playing;
-            const intent = ++playbackIntent;
+            const intent = beginPlaybackIntent();
             await releaseGesture();
+            /* A play superseded while the gesture was releasing must not open a
+               readiness hold: nothing would be left holding the one that replaced
+               it. */
+            if (intent !== playbackIntent) {
+                publishPlaybackState();
+                return;
+            }
             if (options.waitForReadiness) {
+                const readinessWait = new AbortController();
+                activeReadinessWait = readinessWait;
                 readinessHoldIntent = intent;
                 publishPlaybackState();
+                let readinessLanded = false;
                 try {
-                    await options.waitForReadiness(channel.getPlayhead().mediaTimeS);
+                    await options.waitForReadiness(channel.getPlayhead().mediaTimeS, readinessWait.signal);
+                    readinessLanded = true;
                 }
                 finally {
+                    if (activeReadinessWait === readinessWait) {
+                        activeReadinessWait = undefined;
+                    }
                     if (readinessHoldIntent === intent) {
                         readinessHoldIntent = null;
                     }
+                    // A wait that failed takes the play with it, and the producer is
+                    // still frozen for a hold this play took over.
+                    if (!readinessLanded && intent === playbackIntent) {
+                        void releaseReadinessFreeze();
+                    }
                 }
                 if (intent !== playbackIntent) {
                     publishPlaybackState();
                     return;
                 }
             }
+            await releaseReadinessFreeze();
             await channel.play();
             // A producer already at speed reports no change, so nothing else would
             // retire the hold's own Buffering and it would stand for good.
             publishPlaybackState();
         },
         pause() {
+            options.invalidatePresentedFrame?.();
+            presentationWait += 1;
+            presentationHold = null;
             settledState = MediaRendererPlaybackState.Paused;
-            playbackIntent++;
+            beginPlaybackIntent();
             // A pause ends the producer's mechanical hold, so it lands ahead of the
-            // release the open gesture still owes.
+            // releases a readiness hold or an open gesture still owe.
             channel.pause();
+            void releaseReadinessFreeze();
             void releaseGesture();
         },
         async togglePlayback() {
@@ -3980,15 +3196,22 @@ function createMediaRendererTransport(options) {
             // A drag whose landing seek is still releasing the producer is the drag
             // this scrub belongs to. Opening a second one there would stop the
             // picture for a gesture nobody is holding, and nothing would release it.
-            playbackIntent++;
+            options.invalidatePresentedFrame?.();
+            presentationWait += 1;
+            presentationHold = null;
+            beginPlaybackIntent();
             if (!gestureInFlight && landingRelease === null) {
                 gestureInFlight = true;
                 channel.beginInteractiveSeek();
                 publishSeekSignals();
             }
-            channel.scrub(mediaTime * MILLISECONDS_PER_SECOND$1, "gesture");
+            channel.scrub(mediaTime * MILLISECONDS_PER_SECOND$2, "gesture");
         },
         async commit(mediaTime) {
+            options.invalidatePresentedFrame?.();
+            const navigationPresentation = ++presentationWait;
+            presentationHold = null;
+            beginPlaybackIntent();
             // Releasing first is what keeps a drag from freezing the picture on
             // release: the producer resumes on its own terms, and the landing decode
             // for a cold region no longer sits between the pointer coming up and
@@ -3997,23 +3220,100 @@ function createMediaRendererTransport(options) {
             landingRelease = release;
             try {
                 await release;
+                if (navigationPresentation === presentationWait) {
+                    await releaseReadinessFreeze();
+                }
             }
             finally {
                 if (landingRelease === release) {
                     landingRelease = null;
                 }
             }
-            await channel.commit(mediaTime * MILLISECONDS_PER_SECOND$1);
+            const presentation = options.beginPresentedFrameNavigation?.();
+            try {
+                await channel.commit(mediaTime * MILLISECONDS_PER_SECOND$2);
+                await presentation?.waitFor(channel.getPlayhead().frame);
+            }
+            catch (error) {
+                presentation?.cancel();
+                throw error;
+            }
         },
         async step(direction) {
+            options.invalidatePresentedFrame?.();
+            const navigationPresentation = ++presentationWait;
+            presentationHold = null;
+            beginPlaybackIntent();
             await releaseGesture();
-            await channel.step(direction);
+            if (navigationPresentation === presentationWait) {
+                await releaseReadinessFreeze();
+            }
+            const presentation = options.beginPresentedFrameNavigation?.();
+            const before = channel.getPlayhead().frame;
+            try {
+                await channel.step(direction);
+                const after = channel.getPlayhead().frame;
+                if (before.index === after.index && before.ticks === after.ticks) {
+                    // A boundary step intentionally emits no replacement frame. The
+                    // frame already on screen remains authoritative, but it predates
+                    // this navigation ticket and therefore cannot acknowledge it.
+                    presentation?.cancel();
+                }
+                else {
+                    await presentation?.waitFor(after);
+                }
+            }
+            catch (error) {
+                presentation?.cancel();
+                throw error;
+            }
         },
         setPlaybackRate(rate) {
             channel.setPlaybackRate(rate);
         },
+        protectPresentation(mediaTime, signal) {
+            if (!options.waitForPresentationReadiness)
+                return null;
+            const guarded = options.waitForPresentationReadiness(mediaTime, signal);
+            if (!guarded) {
+                if (presentationHold) {
+                    presentationWait += 1;
+                    presentationHold = null;
+                    void releaseReadinessFreeze().then(publishPlaybackState);
+                }
+                return null;
+            }
+            const wait = ++presentationWait;
+            const intent = playbackIntent;
+            presentationHold = { intent, wait };
+            readinessFreezeHeld = true;
+            channel.beginInteractiveSeek();
+            publishPlaybackState();
+            return (async () => {
+                try {
+                    await guarded;
+                }
+                catch {
+                    // A readiness provider failure degrades annotations, not media. The
+                    // provider's diagnostics own the error while the frame stays visible.
+                }
+                finally {
+                    if (presentationHold?.wait === wait) {
+                        presentationHold = null;
+                    }
+                    // An aborted frame hands the existing freeze to a newer frame. A
+                    // navigation increments presentationWait and releases explicitly.
+                    if (wait === presentationWait && !signal.aborted) {
+                        await releaseReadinessFreeze();
+                        publishPlaybackState();
+                    }
+                }
+            })();
+        },
         destroy() {
-            playbackIntent++;
+            presentationWait += 1;
+            presentationHold = null;
+            beginPlaybackIntent();
             for (const unsubscribe of unsubscribes) {
                 unsubscribe();
             }
@@ -4057,6 +3357,240 @@ function isSettling(status, seeking) {
     return seeking || status === "SEEKING";
 }
 
+/**
+ * Holds the newest producer frame until both the scene and its readiness guard
+ * can accept it. A superseding frame aborts the old guard and closes the old
+ * VideoFrame, so stale readiness can never authorize presentation after a new
+ * seek. The downstream handler owns a frame only after the guard succeeds.
+ */
+function createProtectedPresentedFrameSource(upstream, onPresentationError = () => undefined) {
+    let downstream = null;
+    let protect = null;
+    let pending = null;
+    let active = null;
+    let navigation = null;
+    let generation = 0;
+    let destroyed = false;
+    let firstPresented = false;
+    let resolveFirstPresentation;
+    let rejectFirstPresentation;
+    const firstPresentation = new Promise((resolve, reject) => {
+        resolveFirstPresentation = resolve;
+        rejectFirstPresentation = reject;
+    });
+    // A retained seed can fail its guard during activate(), before the core has
+    // reached its await. Keep the rejection owned until that caller observes it.
+    void firstPresentation.catch(() => undefined);
+    const closeRun = (run) => {
+        if (run.closed || run.handedOff)
+            return;
+        run.closed = true;
+        run.frame.frame.close();
+    };
+    const frameKey = (frameId) => `${frameId.index}:${frameId.ticks}`;
+    const settleNavigation = (ticket, error) => {
+        if (ticket.settled)
+            return;
+        ticket.settled = true;
+        if (navigation === ticket)
+            navigation = null;
+        if (error === undefined)
+            ticket.resolve();
+        else
+            ticket.reject(error);
+    };
+    const acceptNavigationFrame = (frameId) => {
+        const ticket = navigation;
+        if (!ticket || ticket.settled)
+            return;
+        const accepted = frameKey(frameId);
+        ticket.accepted.add(accepted);
+        if (ticket.target === accepted)
+            settleNavigation(ticket);
+    };
+    const failPresentation = (error) => {
+        if (!firstPresented)
+            rejectFirstPresentation(error);
+        if (navigation)
+            settleNavigation(navigation, error);
+        if (firstPresented)
+            onPresentationError(error);
+    };
+    const cancelActive = () => {
+        const run = active;
+        if (!run)
+            return;
+        active = null;
+        run.controller.abort();
+        closeRun(run);
+    };
+    const pump = () => {
+        if (destroyed || active || !pending || !downstream || !protect)
+            return;
+        const frame = pending;
+        pending = null;
+        const controller = new AbortController();
+        const run = {
+            closed: false,
+            controller,
+            frame,
+            generation,
+            handedOff: false,
+        };
+        active = run;
+        const handOff = () => {
+            if (destroyed ||
+                controller.signal.aborted ||
+                run.generation !== generation) {
+                closeRun(run);
+                return;
+            }
+            if (active === run)
+                active = null;
+            run.handedOff = true;
+            try {
+                const acknowledge = frame.acknowledgePresentation;
+                downstream(acknowledge
+                    ? {
+                        ...frame,
+                        acknowledgePresentation: () => {
+                            if (destroyed ||
+                                controller.signal.aborted ||
+                                run.generation !== generation) {
+                                return;
+                            }
+                            acknowledge();
+                        },
+                    }
+                    : frame);
+            }
+            catch (error) {
+                failPresentation(error);
+                return;
+            }
+            acceptNavigationFrame(frame.frameId);
+            if (!firstPresented) {
+                firstPresented = true;
+                resolveFirstPresentation();
+            }
+        };
+        let guarded;
+        try {
+            guarded = protect(frame, controller.signal);
+        }
+        catch (error) {
+            active = null;
+            closeRun(run);
+            failPresentation(error);
+            pump();
+            return;
+        }
+        if (!guarded) {
+            handOff();
+            pump();
+            return;
+        }
+        void guarded
+            .then(() => {
+            handOff();
+        })
+            .catch((error) => {
+            closeRun(run);
+            if (!controller.signal.aborted)
+                failPresentation(error);
+        })
+            .finally(() => {
+            if (active === run)
+                active = null;
+            pump();
+        });
+    };
+    upstream.onPresentedFrame((presented) => {
+        if (destroyed) {
+            presented.frame.close();
+            return;
+        }
+        generation += 1;
+        cancelActive();
+        pending?.frame.close();
+        pending = presented;
+        pump();
+    });
+    return {
+        source: {
+            onPresentedFrame(handler) {
+                downstream = handler;
+                pump();
+            },
+        },
+        activate(nextProtect) {
+            protect = nextProtect;
+            pump();
+        },
+        invalidate() {
+            generation += 1;
+            cancelActive();
+            pending?.frame.close();
+            pending = null;
+            if (navigation)
+                settleNavigation(navigation);
+        },
+        beginNavigation() {
+            generation += 1;
+            cancelActive();
+            pending?.frame.close();
+            pending = null;
+            if (navigation)
+                settleNavigation(navigation);
+            let resolve;
+            let reject;
+            const promise = new Promise((onResolve, onReject) => {
+                resolve = onResolve;
+                reject = onReject;
+            });
+            // A scene may fail before the transport reaches waitFor(). Keep the
+            // rejection owned until the navigation command observes it.
+            void promise.catch(() => undefined);
+            const ticket = {
+                accepted: new Set(),
+                promise,
+                reject,
+                resolve,
+                settled: false,
+                target: null,
+            };
+            navigation = ticket;
+            return {
+                waitFor(frameId) {
+                    if (ticket.settled)
+                        return ticket.promise;
+                    ticket.target = frameKey(frameId);
+                    if (ticket.accepted.has(ticket.target))
+                        settleNavigation(ticket);
+                    return ticket.promise;
+                },
+                cancel() {
+                    settleNavigation(ticket);
+                },
+            };
+        },
+        waitForFirstPresentation: () => firstPresentation,
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            generation += 1;
+            cancelActive();
+            pending?.frame.close();
+            pending = null;
+            if (navigation)
+                settleNavigation(navigation);
+            upstream.onPresentedFrame((presented) => presented.frame.close());
+            if (!firstPresented)
+                resolveFirstPresentation();
+        },
+    };
+}
 /**
  * Reads the presented-frame plane an opened media source publishes as `engine`.
  * A source without one is pull-only, and the renderer keeps driving it by
@@ -4081,6 +3615,45 @@ function isPresentedFrameChannel(value) {
         typeof candidate.subscribe === "function");
 }
 
+const MILLISECONDS_PER_SECOND$1 = 1000;
+/**
+ * Two seconds of frozen picture for masks that have not been cooked.
+ *
+ * Preparation is local work, so a lead it cannot rebuild in this long is one it
+ * is losing rather than one that is late, and every further second is spent on
+ * a picture that has stopped. The detection gate waits five times as long
+ * because what it waits on is a model somewhere else.
+ */
+function resolveRenderPreparationMaxWaitSeconds(value) {
+    if (value === undefined) {
+        return DEFAULT_RENDER_PREPARATION_GATE_MAX_WAIT_SECONDS;
+    }
+    if (value === Number.POSITIVE_INFINITY)
+        return value;
+    if (Number.isNaN(value)) {
+        return DEFAULT_RENDER_PREPARATION_GATE_MAX_WAIT_SECONDS;
+    }
+    return Math.max(0, value);
+}
+/**
+ * A tenth of a second of runway left, and a fifth of a second more banked
+ * before the picture moves again.
+ *
+ * A viewer counts a stop in their own seconds rather than seconds of timeline,
+ * so both are wall-clock and the playback rate converts them. The resume is
+ * the stop plus a margin, which fixes the length of a stop at that margin: how
+ * deep a bank preparation aims for is then a question about memory and cooks
+ * alone.
+ */
+/**
+ * Ceiling on a stop threshold as a share of the lead that ends the stop.
+ *
+ * A requirement too small to fund the margin caps the resume lead below the
+ * stop threshold the wall clock asks for, and a gate that stops and resumes at
+ * one lead stops again on the frame it just released. Half the resume lead is
+ * the widest stop threshold that still leaves a stop something to wait for.
+ */
+const RENDER_PREPARATION_GATE_MAX_STOP_SHARE_OF_RESUME = 0.5;
 async function createMediaRendererCore(options, providers) {
     const fit = options.fit ?? MediaRendererFit.Contain;
     const initialPlaybackRate = options.playbackRate ?? 1;
@@ -4119,24 +3692,29 @@ async function createMediaRendererCore(options, providers) {
         mediaScene?.setPlaybackActive?.(runtimeState.isPlaybackActive() || isSeekGestureInFlight);
     };
     const endSeekGesture = () => {
+        cancelPullScrubPreview();
         isSeekGestureInFlight = false;
         publishPlaybackActivity();
     };
+    /**
+     * A hold reads the rate once, so the thresholds it is waiting on are the
+     * ones the old rate implied. Ending the hold hands the next frame back to
+     * the gate, which asks again at the rate now in force.
+     */
+    let renderPreparationRateEpoch = new AbortController();
     const adoptPlaybackRate = (playbackRate) => {
+        if (playbackRate === runtimeState.playbackRate()) {
+            return;
+        }
         runtimeState.setPlaybackRate(playbackRate);
+        const supersededHolds = renderPreparationRateEpoch;
+        renderPreparationRateEpoch = new AbortController();
+        supersededHolds.abort();
     };
-    let presentsOwnFrames = false;
     const runtimeState = createMediaRendererRuntimeState({
         fit,
         playbackRate: initialPlaybackRate,
-        getPlaybackGateReach: () => !shouldGatePlayback
-            ? PlaybackGateReach.Off
-            : // Stopping a producer that owns the playhead is something only the
-                // detection gate does, so a self-presenting source held for render
-                // preparation alone still waits once and never again.
-                presentsOwnFrames && !shouldGateDetectionPlayback
-                    ? PlaybackGateReach.StartOfPlayback
-                    : PlaybackGateReach.EveryFrame,
+        getPlaybackGateReach: () => shouldGatePlayback ? PlaybackGateReach.EveryFrame : PlaybackGateReach.Off,
         getDetectionBufferState: () => detectionTimeline?.getState() ?? createIdleDetectionBufferState(),
         onFrame: options.onFrame,
         onSource: options.onSource,
@@ -4149,9 +3727,44 @@ async function createMediaRendererCore(options, providers) {
     let mediaInput;
     let playbackController;
     let transport;
+    let protectedPresentedFrames;
+    let pushPresentationReady = false;
     let sampleSink;
     let firstTimestamp = 0;
     let navigationVersion = 0;
+    let outstandingSourceReads = 0;
+    let pendingPullScrubTime = null;
+    let pullScrubEpoch = 0;
+    let pullScrubReadInFlight = false;
+    let pullScrubScheduled = false;
+    const cancelPullScrubPreview = () => {
+        pendingPullScrubTime = null;
+        pullScrubEpoch += 1;
+        if (pullScrubReadInFlight) {
+            navigationVersion += 1;
+        }
+    };
+    const beginSourceRead = () => {
+        outstandingSourceReads += 1;
+        if (outstandingSourceReads === 1) {
+            runtimeState.setSourceAwaitingRead(true);
+        }
+    };
+    const endSourceRead = () => {
+        outstandingSourceReads -= 1;
+        if (outstandingSourceReads === 0) {
+            runtimeState.setSourceAwaitingRead(false);
+        }
+    };
+    const trackSourceRead = async (read) => {
+        beginSourceRead();
+        try {
+            return await read;
+        }
+        finally {
+            endSourceRead();
+        }
+    };
     const adoptTransportPlaybackState = (state) => {
         // Not gated on isError: the producer owns playback truth here, so a
         // recovery after a transient error must be adopted, not ignored forever.
@@ -4169,7 +3782,8 @@ async function createMediaRendererCore(options, providers) {
                 runtimeState.setPaused();
                 break;
             case MediaRendererPlaybackState.Ready:
-                runtimeState.setReady();
+                if (pushPresentationReady)
+                    runtimeState.setReady();
                 break;
             case MediaRendererPlaybackState.Loading:
                 runtimeState.setLoading();
@@ -4194,36 +3808,197 @@ async function createMediaRendererCore(options, providers) {
     const shouldGateDetectionPlayback = detectionPlaybackGate?.enabled === true;
     const shouldGateRenderPreparationPlayback = renderPreparationPlaybackGate?.enabled === true;
     const shouldGatePlayback = shouldGateDetectionPlayback || shouldGateRenderPreparationPlayback;
-    const waitForPlaybackReadiness = async (mediaTime) => {
+    const renderPreparationGateMaxWaitSeconds = resolveRenderPreparationMaxWaitSeconds(renderPreparationPlaybackGate?.maxWaitSeconds);
+    /**
+     * The gate's wall-clock thresholds in seconds of timeline, which is the unit
+     * a prepared lead is measured in. A rate is how many seconds of timeline a
+     * second of runway is worth, so at 8x a tenth of a second of picture is
+     * eight tenths of a second of frames.
+     *
+     * `requiredAheadSeconds` is a ceiling on the resume lead, and the stop
+     * threshold is held under that lead: a requirement of a single frame still
+     * buys a stop that ends higher than it began, at the price of a band
+     * narrower than the wall clock asked for. Zero on both sides is the one pair
+     * that meets, and there the lead gate is off and only an unprepared frame
+     * under the playhead stops the picture.
+     */
+    const resolveRenderPreparationGateThresholds = () => {
+        const playbackRate = runtimeState.playbackRate();
+        const bankSeconds = Math.max(renderPreparationPlaybackGate?.requiredAheadSeconds ?? 0, 0);
+        const stopBelowWallSeconds = Math.max(renderPreparationPlaybackGate?.stopBelowWallSeconds ??
+            DEFAULT_RENDER_PREPARATION_GATE_STOP_BELOW_WALL_SECONDS, 0);
+        const resumeMarginWallSeconds = Math.max(renderPreparationPlaybackGate?.resumeMarginWallSeconds ??
+            DEFAULT_RENDER_PREPARATION_GATE_RESUME_MARGIN_WALL_SECONDS, 0);
+        const resumeAtSeconds = Math.min(bankSeconds, (stopBelowWallSeconds + resumeMarginWallSeconds) * playbackRate);
+        return {
+            enabled: renderPreparationPlaybackGate?.enabled,
+            resumeAtSeconds,
+            stopBelowSeconds: Math.min(stopBelowWallSeconds * playbackRate, resumeAtSeconds * RENDER_PREPARATION_GATE_MAX_STOP_SHARE_OF_RESUME),
+        };
+    };
+    /**
+     * Where preparation stood when the hold that last gave up opened, or null
+     * while the gate is armed. Preparation that has finished a frame since is
+     * preparation that is running, however far behind the playhead it still is,
+     * and the gate is worth spending again on it. The frame that says so lands
+     * during the hold on a machine where cooking and decoding contend for one
+     * core, which is why the mark is the hold's start and not its end.
+     */
+    let abandonedGateProgress = null;
+    const readRenderPreparationProgress = () => mediaScene?.getRenderPreparationProgress?.() ?? 0;
+    const hasAbandonedRenderPreparationGate = () => abandonedGateProgress !== null &&
+        readRenderPreparationProgress() <= abandonedGateProgress;
+    const armRenderPreparationGate = () => {
+        abandonedGateProgress = null;
+        runtimeState.setRenderPreparationGateAbandoned(false);
+    };
+    const abandonRenderPreparationGate = (progressAtHoldStart) => {
+        abandonedGateProgress = progressAtHoldStart;
+        runtimeState.setRenderPreparationGateAbandoned(true);
+    };
+    /**
+     * Holds the picture for prepared artifacts, under the gate's bound.
+     *
+     * Preparation that has fallen behind is indistinguishable from a cook still
+     * on its way, and the bound is the way back out of a hold on one that will
+     * never answer. Giving up lasts only until preparation finishes another
+     * frame: a preparer that is merely losing to the playhead is still a
+     * preparer, and the picture it feeds is worth stopping for again. One that
+     * has finished nothing since is stuck, and the gate stays out of its way
+     * rather than spending the bound once a frame on it.
+     */
+    const waitForRenderPreparationWithin = async (mediaTime, signal) => {
+        const bound = new AbortController();
+        const abortBound = () => bound.abort();
+        const rateEpoch = renderPreparationRateEpoch.signal;
+        const progressAtHoldStart = readRenderPreparationProgress();
+        const expiry = Number.isFinite(renderPreparationGateMaxWaitSeconds)
+            ? setTimeout(() => {
+                abandonRenderPreparationGate(progressAtHoldStart);
+                bound.abort();
+            }, renderPreparationGateMaxWaitSeconds * MILLISECONDS_PER_SECOND$1)
+            : undefined;
+        signal.addEventListener("abort", abortBound);
+        rateEpoch.addEventListener("abort", abortBound);
+        try {
+            await mediaScene?.waitForRenderPreparation?.(mediaTime, resolveRenderPreparationGateThresholds(), bound.signal);
+        }
+        finally {
+            clearTimeout(expiry);
+            signal.removeEventListener("abort", abortBound);
+            rateEpoch.removeEventListener("abort", abortBound);
+        }
+    };
+    const waitForDetectionCoverage = (mediaTime) => detectionTimeline?.prepare(mediaTime, {
+        duration: runtimeState.duration(),
+        firstTimestamp,
+        gatePlayback: true,
+    });
+    /**
+     * The wait a play makes before the picture starts moving. A play is a fresh
+     * intent, so it arms a gate an earlier run gave up on: the frame the viewer
+     * is about to be shown is the one they asked to see annotated.
+     */
+    const waitForPlaybackReadiness = async (mediaTime, signal) => {
         if (shouldGateDetectionPlayback) {
-            await detectionTimeline?.prepare(mediaTime, {
-                duration: runtimeState.duration(),
-                firstTimestamp,
-                gatePlayback: true,
-            });
+            await waitForDetectionCoverage(mediaTime);
         }
         if (shouldGateRenderPreparationPlayback) {
-            await mediaScene?.waitForRenderPreparation?.(mediaTime, renderPreparationPlaybackGate ?? {});
+            armRenderPreparationGate();
+            await waitForRenderPreparationWithin(mediaTime, signal);
         }
     };
-    /**
-     * The detection gate alone, because it is the one that bounds its own wait
-     * and gives up on a producer that has stopped answering. Render preparation
-     * waits until the artifacts exist, which is a wait to start playback and
-     * never one to stop it with.
-     */
-    const holdForDetectionCoverage = (mediaTime) => {
-        const prepareOptions = {
-            duration: runtimeState.duration(),
-            firstTimestamp,
-        };
-        if (detectionTimeline?.needsPlaybackGateWait?.(mediaTime, prepareOptions) !==
-            true) {
+    /**
+     * A gate that gave up comes back on preparation finishing another frame, and
+     * on the playhead reaching frames preparation finished already: a loop or a
+     * seek back lands inside a window that is covered, and coverage cooked before
+     * the hold moves no progress count.
+     */
+    const holdForSampleReadiness = async (mediaTime, signal) => {
+        if (shouldGateDetectionPlayback) {
+            await waitForDetectionCoverage(mediaTime);
+        }
+        if (!shouldGateRenderPreparationPlayback) {
+            return;
+        }
+        const isRenderPreparationCovered = mediaScene?.needsRenderPreparationWait?.(mediaTime, resolveRenderPreparationGateThresholds()) === false;
+        if (!isRenderPreparationCovered && hasAbandonedRenderPreparationGate()) {
+            return;
+        }
+        armRenderPreparationGate();
+        await waitForRenderPreparationWithin(mediaTime, signal);
+    };
+    const holdForDetectionCoverage = (mediaTime) => {
+        if (!detectionTimeline ||
+            (detectionTimeline.needsBufferPrepare?.(mediaTime) !== true &&
+                detectionTimeline.needsPlaybackGateWait?.(mediaTime, {
+                    duration: runtimeState.duration(),
+                    firstTimestamp,
+                    gatePlayback: true,
+                }) !== true)) {
+            return null;
+        }
+        return detectionTimeline.prepare(mediaTime, {
+            duration: runtimeState.duration(),
+            firstTimestamp,
+            gatePlayback: true,
+        });
+    };
+    const holdForRenderPreparation = (mediaTime, signal) => {
+        if (mediaScene?.needsRenderPreparationWait?.(mediaTime, resolveRenderPreparationGateThresholds()) !== true) {
+            armRenderPreparationGate();
+            return null;
+        }
+        if (hasAbandonedRenderPreparationGate())
+            return null;
+        armRenderPreparationGate();
+        return waitForRenderPreparationWithin(mediaTime, signal);
+    };
+    /** Detaches a readiness source that does not implement cancellation itself.
+     * Its eventual rejection remains owned while a superseding frame can start
+     * its own guard immediately. */
+    const abortableReadiness = (wait, signal) => {
+        if (signal.aborted) {
+            void wait.catch(() => undefined);
+            return Promise.resolve();
+        }
+        let onAbort = () => { };
+        const aborted = new Promise((resolve) => {
+            onAbort = resolve;
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+        void wait.catch(() => undefined);
+        return Promise.race([wait.then(() => undefined), aborted]).finally(() => {
+            signal.removeEventListener("abort", onAbort);
+        });
+    };
+    const holdForPresentationReadiness = (mediaTime, signal) => {
+        const combined = new AbortController();
+        const abortCombined = () => combined.abort();
+        if (signal.aborted)
+            abortCombined();
+        else
+            signal.addEventListener("abort", abortCombined, { once: true });
+        const holds = [];
+        const detection = shouldGateDetectionPlayback
+            ? holdForDetectionCoverage(mediaTime)
+            : null;
+        const preparation = shouldGateRenderPreparationPlayback
+            ? holdForRenderPreparation(mediaTime, combined.signal)
+            : null;
+        if (detection)
+            holds.push(abortableReadiness(detection, combined.signal));
+        if (preparation)
+            holds.push(abortableReadiness(preparation, combined.signal));
+        if (holds.length === 0) {
+            signal.removeEventListener("abort", abortCombined);
             return null;
         }
-        return detectionTimeline.prepare(mediaTime, {
-            ...prepareOptions,
-            gatePlayback: true,
+        return Promise.all(holds)
+            .then(() => undefined)
+            .finally(() => {
+            signal.removeEventListener("abort", abortCombined);
+            combined.abort();
         });
     };
     const presentSample = (sample) => {
@@ -4261,6 +4036,74 @@ async function createMediaRendererCore(options, providers) {
             }
         }
     };
+    const seekPullSample = async (targetTime) => {
+        if (!playbackController || !sampleSink) {
+            throw new Error("Media renderer is not ready.");
+        }
+        // A seek taken while buffering should resume playback, not strand it:
+        // buffering means playback was requested and is waiting for data.
+        const wasPlaying = runtimeState.isPlaybackActive();
+        const requestVersion = ++navigationVersion;
+        playbackController.pause();
+        try {
+            const sample = await trackSourceRead(sampleSink.getSample(targetTime, { skipLiveWait: true }));
+            if (!sample) {
+                throw new Error("No decoded video sample was found for seek.");
+            }
+            if (requestVersion !== navigationVersion || runtimeState.isDestroyed()) {
+                sample.close();
+                return;
+            }
+            await prepareAndPresentSample(sample, () => requestVersion === navigationVersion && !runtimeState.isDestroyed());
+            if (requestVersion !== navigationVersion || runtimeState.isDestroyed()) {
+                return;
+            }
+            playbackController.seek(runtimeState.currentTime());
+            if (wasPlaying) {
+                runtimeState.setPlaying();
+                playbackController.play();
+            }
+            else if (runtimeState.isBuffering()) {
+                // Seeking always leaves the controller paused. Settle the reported
+                // state so the session is paused rather than perpetually buffering.
+                runtimeState.setPaused();
+            }
+        }
+        catch (error) {
+            if (requestVersion !== navigationVersion || runtimeState.isDestroyed()) {
+                return;
+            }
+            runtimeState.setRenderError(error);
+            throw error;
+        }
+    };
+    const schedulePullScrubPreview = () => {
+        if (pullScrubScheduled ||
+            pullScrubReadInFlight ||
+            pendingPullScrubTime === null) {
+            return;
+        }
+        pullScrubScheduled = true;
+        const scheduledEpoch = pullScrubEpoch;
+        queueMicrotask(() => {
+            pullScrubScheduled = false;
+            if (scheduledEpoch !== pullScrubEpoch ||
+                pendingPullScrubTime === null ||
+                runtimeState.isDestroyed()) {
+                schedulePullScrubPreview();
+                return;
+            }
+            const targetTime = pendingPullScrubTime;
+            pendingPullScrubTime = null;
+            pullScrubReadInFlight = true;
+            void seekPullSample(targetTime)
+                .catch(() => undefined)
+                .finally(() => {
+                pullScrubReadInFlight = false;
+                schedulePullScrubPreview();
+            });
+        });
+    };
     const renderer = {
         async play() {
             if (runtimeState.isDestroyed()) {
@@ -4283,6 +4126,10 @@ async function createMediaRendererCore(options, providers) {
             if (runtimeState.isPlaying()) {
                 return;
             }
+            // A source the renderer pulls samples from has no readiness wait of its
+            // own: its start of playback is the first per-sample hold, so the fresh
+            // intent arms the gate here.
+            armRenderPreparationGate();
             runtimeState.setPlaying();
             playbackController.play();
         },
@@ -4333,50 +4180,7 @@ async function createMediaRendererCore(options, providers) {
                 await transport.commit(targetTime);
                 return;
             }
-            if (!playbackController || !sampleSink) {
-                throw new Error("Media renderer is not ready.");
-            }
-            // A seek taken while buffering should resume playback, not strand it:
-            // buffering means playback was requested and is waiting for data.
-            const wasPlaying = runtimeState.isPlaybackActive();
-            const requestVersion = ++navigationVersion;
-            playbackController.pause();
-            try {
-                const sample = await sampleSink.getSample(targetTime, {
-                    skipLiveWait: true,
-                });
-                if (!sample) {
-                    throw new Error("No decoded video sample was found for seek.");
-                }
-                if (requestVersion !== navigationVersion ||
-                    runtimeState.isDestroyed()) {
-                    sample.close();
-                    return;
-                }
-                await prepareAndPresentSample(sample, () => requestVersion === navigationVersion && !runtimeState.isDestroyed());
-                if (requestVersion !== navigationVersion ||
-                    runtimeState.isDestroyed()) {
-                    return;
-                }
-                playbackController.seek(runtimeState.currentTime());
-                if (wasPlaying) {
-                    runtimeState.setPlaying();
-                    playbackController.play();
-                }
-                else if (runtimeState.isBuffering()) {
-                    // Seeking always leaves the controller paused. Settle the reported
-                    // state so the session is paused rather than perpetually buffering.
-                    runtimeState.setPaused();
-                }
-            }
-            catch (error) {
-                if (requestVersion !== navigationVersion ||
-                    runtimeState.isDestroyed()) {
-                    return;
-                }
-                runtimeState.setRenderError(error);
-                throw error;
-            }
+            await seekPullSample(targetTime);
         },
         scrub(mediaTime) {
             if (runtimeState.isDestroyed() || runtimeState.isError()) {
@@ -4393,7 +4197,11 @@ async function createMediaRendererCore(options, providers) {
                 transport.scrub(targetTime);
                 return;
             }
-            void renderer.seek(targetTime).catch(() => undefined);
+            pendingPullScrubTime = targetTime;
+            if (pullScrubReadInFlight) {
+                navigationVersion += 1;
+            }
+            schedulePullScrubPreview();
         },
         async stepForward() {
             await stepToAdjacentSample("forward");
@@ -4429,7 +4237,7 @@ async function createMediaRendererCore(options, providers) {
             if (!mediaScene) {
                 throw new Error("Media renderer is not ready.");
             }
-            const mediaTime = runtimeState.currentTime();
+            const mediaTime = runtimeState.presentedTime() ?? runtimeState.currentTime();
             const requestVersion = navigationVersion;
             await detectionTimeline?.prepare(mediaTime, {
                 duration: runtimeState.duration(),
@@ -4475,7 +4283,8 @@ async function createMediaRendererCore(options, providers) {
                 return;
             }
             currentPresentation = resolvePresentation(presentation);
-            const presentedSample = mediaScene?.setPresentation(currentPresentation, runtimeState.currentTime());
+            const mediaTime = runtimeState.presentedTime() ?? runtimeState.currentTime();
+            const presentedSample = mediaScene?.setPresentation(currentPresentation, mediaTime);
             if (presentedSample) {
                 runtimeState.recordPresentationUpdate(presentedSample);
             }
@@ -4527,7 +4336,9 @@ async function createMediaRendererCore(options, providers) {
             if (runtimeState.isDestroyed()) {
                 return;
             }
+            cancelPullScrubPreview();
             runtimeState.markDestroyed();
+            protectedPresentedFrames?.destroy();
             transport?.destroy();
             playbackController?.destroy();
             stopActiveIterator();
@@ -4571,7 +4382,18 @@ async function createMediaRendererCore(options, providers) {
             ...options.detectionBuffer,
         });
         const presentedFrameChannel = resolvePresentedFrameChannel(mediaSource);
-        presentsOwnFrames = presentedFrameChannel !== null;
+        protectedPresentedFrames = presentedFrameChannel
+            ? createProtectedPresentedFrameSource(presentedFrameChannel, (error) => {
+                // A scene that can no longer accept pixels cannot recover because
+                // the producer keeps running. Cut off future frames and state
+                // signals before publishing the rendering failure.
+                protectedPresentedFrames?.destroy();
+                transport?.destroy();
+                presentedFrameChannel.pause();
+                if (!runtimeState.isDestroyed())
+                    runtimeState.setRenderError(error);
+            })
+            : undefined;
         const mediaDimensions = runtimeState.recordMediaMetadata(metadata);
         mediaScene = await providers.createScene({
             annotationOverlayStyle: currentPresentation.annotationOverlayStyle,
@@ -4602,7 +4424,7 @@ async function createMediaRendererCore(options, providers) {
             },
             polygonStyle: currentPresentation.polygonStyle,
             polylineStyle: currentPresentation.polylineStyle,
-            presentedFrames: presentedFrameChannel ?? undefined,
+            presentedFrames: protectedPresentedFrames?.source,
             regionRenderers: resolveRegionRenderers(currentPresentation),
             previewOverlay: options.previewOverlay,
             renderPreparation: options.renderPreparation
@@ -4648,14 +4470,32 @@ async function createMediaRendererCore(options, providers) {
                 waitForReadiness: shouldGatePlayback
                     ? waitForPlaybackReadiness
                     : undefined,
-                holdForReadiness: shouldGateDetectionPlayback
-                    ? holdForDetectionCoverage
+                waitForPresentationReadiness: shouldGatePlayback
+                    ? holdForPresentationReadiness
                     : undefined,
+                invalidatePresentedFrame: () => protectedPresentedFrames?.invalidate(),
+                beginPresentedFrameNavigation: () => protectedPresentedFrames.beginNavigation(),
             });
+            protectedPresentedFrames?.activate((presented, signal) => transport.protectPresentation(presented.mediaTimeS, signal));
             if (initialPlaybackRate !== 1) {
                 transport.setPlaybackRate(initialPlaybackRate);
             }
             detectionTimeline?.prefetch(metadata.firstTimestamp);
+            // Loading is not complete until the scene has accepted real media
+            // pixels. A paused, non-autoplay source otherwise reports Ready over a
+            // blank compositor because the producer's load settled before a frame
+            // consumer existed.
+            await presentedFrameChannel.commit(metadata.firstTimestamp * MILLISECONDS_PER_SECOND$1);
+            await protectedPresentedFrames?.waitForFirstPresentation();
+            // The first accepted frame does not prove the presentation path stayed
+            // healthy until initialization finished. A producer may emit a newer
+            // replacement before commit() resolves, and that handoff can fail after
+            // the first-presentation latch has already opened. Preserve that fatal
+            // state instead of publishing Ready over it or starting autoplay on a
+            // producer the error path just stopped.
+            if (runtimeState.isDestroyed() || runtimeState.isError())
+                return renderer;
+            pushPresentationReady = true;
             runtimeState.setReady();
             if (options.autoPlay ?? true) {
                 await renderer.play();
@@ -4672,7 +4512,7 @@ async function createMediaRendererCore(options, providers) {
         await prepareAndPresentSample(firstSample);
         runtimeState.setReady();
         const waitForSample = shouldGatePlayback
-            ? (sample) => waitForPlaybackReadiness(sample.timestamp)
+            ? (sample, signal) => holdForSampleReadiness(sample.timestamp, signal)
             : undefined;
         playbackController = createMediaPlaybackController({
             duration: runtimeState.duration(),
@@ -4692,6 +4532,14 @@ async function createMediaRendererCore(options, providers) {
                     runtimeState.setPlaying();
                 }
             },
+            onSourceWait(waiting) {
+                if (waiting) {
+                    beginSourceRead();
+                }
+                else {
+                    endSourceRead();
+                }
+            },
             onWaiting() {
                 if (runtimeState.isPlaybackActive()) {
                     runtimeState.setBuffering();
@@ -4736,14 +4584,16 @@ async function createMediaRendererCore(options, providers) {
         let sample = null;
         try {
             if (direction === "backward") {
-                sample = await sampleSink.getSample(Math.max(firstTimestamp, currentTime - epsilon), { skipLiveWait: true });
+                sample = await trackSourceRead(sampleSink.getSample(Math.max(firstTimestamp, currentTime - epsilon), {
+                    skipLiveWait: true,
+                }));
             }
             else {
                 const iterator = sampleSink.samples(currentTime + epsilon, undefined, {
                     skipLiveWait: true,
                 });
                 try {
-                    const result = await iterator.next();
+                    const result = await trackSourceRead(iterator.next());
                     sample = result.done ? null : result.value;
                 }
                 finally {
@@ -4873,7 +4723,7 @@ function encodeCanvas(canvas, type, quality) {
  * silently putting annotations from one moment over pixels from another.
  */
 /**
- * The atomic present: one frame the producer put on screen becomes one screen.
+ * The atomic present: one frame handed to the host becomes one composited screen.
  *
  * The media time is the one the producer published for the frame these pixels
  * are, and it is the only time any step below sees. Nothing here awaits, so no
@@ -4893,6 +4743,7 @@ function presentVideoFrame(presented, targets) {
         const { boxState, regionState } = drawFramePresentLayers(layers, mediaTime, presented);
         targets.render();
         targets.completePresentation(mediaTime, boxState, regionState);
+        presented.acknowledgePresentation?.();
     }
     finally {
         presented.frame.close();
@@ -5079,18 +4930,33 @@ function createIdMaskRasterFrame(instructions, maxRasterWidth) {
         return undefined;
     }
 }
+/**
+ * Whether the palette has a slot for every detection this frame masks. An id
+ * names a detection by its index in the frame, so one masked detection past the
+ * last slot leaves the whole frame without an id raster however few masks it
+ * carries.
+ */
+function canIdMaskPaletteNameFrame(instructions) {
+    return instructions.every((instruction) => instruction.visible === false ||
+        resolveIdMaskPaletteId(instruction.detectionIndex) !== undefined);
+}
 function createIdMaskPlane(instructions, maxRasterWidth) {
+    // The plane carries the ids a failed cook could not. A frame the palette
+    // cannot name has none to carry, and cooking it again reaches the same
+    // refusal after rasterizing every mask a second time.
+    if (!canIdMaskPaletteNameFrame(instructions)) {
+        return undefined;
+    }
     const frame = createIdMaskRasterFrame(instructions, maxRasterWidth);
     return frame
         ? { data: frame.data, height: frame.height, width: frame.width }
         : undefined;
 }
 function compositeInstruction(rgba, canvasWidth, instruction) {
-    const decodedMask = decodeCompressedRleMask(instruction.mask);
     const fill = resolveRgbaColor(instruction.color, instruction.alpha);
-    compositeMaskFill(rgba, canvasWidth, decodedMask, fill);
-    if (instruction.stroke) {
-        compositeMaskStroke(rgba, canvasWidth, decodedMask, instruction.stroke);
+    const bounds = compositeMaskFill(rgba, canvasWidth, instruction.mask, fill);
+    if (instruction.stroke && bounds) {
+        compositeMaskStroke(rgba, canvasWidth, decodeCompressedRleMask(instruction.mask), bounds, instruction.stroke);
     }
 }
 function materializeMaskInstructions(instructions) {
@@ -5110,25 +4976,59 @@ function materializeMaskInstructions(instructions) {
         };
     });
 }
-function compositeMaskFill(rgba, canvasWidth, decodedMask, fill) {
-    for (let y = 0; y < decodedMask.height; y += 1) {
-        for (let x = 0; x < decodedMask.width; x += 1) {
-            const maskOffset = y * decodedMask.width + x;
-            if (!decodedMask.data[maskOffset]) {
-                continue;
+/**
+ * Compressed RLE counts runs down each column in turn, so a foreground run is
+ * a contiguous walk down one column that wraps into the next.
+ */
+function compositeMaskFill(rgba, canvasWidth, mask, fill) {
+    const counts = decodeCompressedRleCounts(mask.counts);
+    const maskWidth = mask.width;
+    const maskHeight = mask.height;
+    const maskArea = maskWidth * maskHeight;
+    let maskOffset = 0;
+    let minX = maskWidth;
+    let minY = maskHeight;
+    let maxX = -1;
+    let maxY = -1;
+    for (let index = 0; index < counts.length; index += 1) {
+        const runLength = counts[index] ?? 0;
+        if (index % 2 === 0 || runLength <= 0) {
+            maskOffset += runLength;
+            continue;
+        }
+        let columnX = Math.floor(maskOffset / maskHeight);
+        let columnY = maskOffset - columnX * maskHeight;
+        for (let step = 0; step < runLength; step += 1) {
+            // A run can outlast the columns the mask has; the pixel it then names
+            // is wherever that column-major offset lands when read back row-major.
+            const rowMajorOffset = columnY * maskWidth + columnX;
+            if (rowMajorOffset < maskArea) {
+                const x = rowMajorOffset % maskWidth;
+                const y = (rowMajorOffset - x) / maskWidth;
+                writePixel(rgba, canvasWidth, x, y, fill);
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+            columnY += 1;
+            if (columnY === maskHeight) {
+                columnY = 0;
+                columnX += 1;
             }
-            writePixel(rgba, canvasWidth, x, y, fill);
         }
+        maskOffset += runLength;
     }
+    return maxX < minX || maxY < minY ? undefined : { maxX, maxY, minX, minY };
 }
-function compositeMaskStroke(rgba, canvasWidth, decodedMask, stroke) {
+function compositeMaskStroke(rgba, canvasWidth, decodedMask, bounds, stroke) {
     const width = Math.round(stroke.width);
     if (width <= 0) {
         return;
     }
     const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);
-    for (let y = 0; y < decodedMask.height; y += 1) {
-        for (let x = 0; x < decodedMask.width; x += 1) {
+    for (let y = bounds.minY; y <= bounds.maxY; y += 1) {
+        for (let x = bounds.minX; x <= bounds.maxX; x += 1) {
             if (!isMaskPixel(decodedMask, x, y) ||
                 !isBoundaryPixel(decodedMask, x, y)) {
                 continue;
@@ -5185,7 +5085,7 @@ function writePixel(rgba, canvasWidth, x, y, color) {
     rgba[rgbaOffset + 3] = color.alpha;
 }
 
-const EMBEDDED_MASK_PREPARATION_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n    function decodeCompressedRleMask(mask) {\n        if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {\n            throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);\n        }\n        const data = new Uint8Array(mask.width * mask.height);\n        const counts = decodeCompressedRleCounts(mask.counts);\n        let offset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            const isForeground = index % 2 === 1;\n            if (isForeground) {\n                for (let runOffset = 0; runOffset < runLength; runOffset += 1) {\n                    const maskOffset = offset + runOffset;\n                    const x = Math.floor(maskOffset / mask.height);\n                    const y = maskOffset % mask.height;\n                    const rowMajorOffset = y * mask.width + x;\n                    if (rowMajorOffset < data.length) {\n                        data[rowMajorOffset] = 1;\n                    }\n                }\n            }\n            offset += runLength;\n        }\n        return {\n            data,\n            height: mask.height,\n            width: mask.width,\n        };\n    }\n    function decodeCompressedRleCounts(counts) {\n        const decoded = [];\n        let index = 0;\n        while (index < counts.length) {\n            let value = 0;\n            let shift = 0;\n            let charCode;\n            do {\n                charCode = counts.charCodeAt(index) - 48;\n                index += 1;\n                value |= (charCode & 0x1f) << shift;\n                shift += 5;\n            } while (charCode & 0x20);\n            if (charCode & 0x10) {\n                value |= -1 << shift;\n            }\n            if (decoded.length > 2) {\n                value += decoded[decoded.length - 2] ?? 0;\n            }\n            decoded.push(value);\n        }\n        return decoded;\n    }\n    function encodeCompressedRleCounts(counts) {\n        return counts\n            .map((count, index) => {\n            let value = index > 2 ? count - counts[index - 2] : count;\n            let encoded = \"\";\n            let more = true;\n            while (more) {\n                let charCode = value & 0x1f;\n                value >>= 5;\n                more = !((value === 0 && (charCode & 0x10) === 0) ||\n                    (value === -1 && (charCode & 0x10) !== 0));\n                if (more) {\n                    charCode |= 0x20;\n                }\n                encoded += String.fromCharCode(charCode + 48);\n            }\n            return encoded;\n        })\n            .join(\"\");\n    }\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n    function encodeBinaryMask(data, width, height) {\n        assertMaskDimensions(data, width, height);\n        const runs = [];\n        let currentValue = 0;\n        let runLength = 0;\n        for (let x = 0; x < width; x += 1) {\n            for (let y = 0; y < height; y += 1) {\n                const value = data[y * width + x] ? 1 : 0;\n                if (value === currentValue) {\n                    runLength += 1;\n                }\n                else {\n                    runs.push(runLength);\n                    currentValue = value;\n                    runLength = 1;\n                }\n            }\n        }\n        runs.push(runLength);\n        return {\n            counts: encodeCompressedRleCounts(runs),\n            encoding: DetectionMaskEncoding.CompressedRle,\n            height,\n            width,\n        };\n    }\n    function assertMaskSize(width, height) {\n        if (!Number.isInteger(width) || width <= 0) {\n            throw new Error(\"Mask width must be a positive integer.\");\n        }\n        if (!Number.isInteger(height) || height <= 0) {\n            throw new Error(\"Mask height must be a positive integer.\");\n        }\n    }\n    function assertMaskDimensions(data, width, height) {\n        assertMaskSize(width, height);\n        if (data.length !== width * height) {\n            throw new Error(\"Mask data length must equal width * height.\");\n        }\n    }\n\n    function centerRectToTopLeftRect(rect) {\n        return {\n            height: rect.height,\n            width: rect.width,\n            x: rect.x - rect.width / 2,\n            y: rect.y - rect.height / 2,\n        };\n    }\n    function getPointsRect(points) {\n        if (points.length === 0) {\n            return undefined;\n        }\n        let minX = Number.POSITIVE_INFINITY;\n        let minY = Number.POSITIVE_INFINITY;\n        let maxX = Number.NEGATIVE_INFINITY;\n        let maxY = Number.NEGATIVE_INFINITY;\n        for (const point of points) {\n            minX = Math.min(minX, point.x);\n            minY = Math.min(minY, point.y);\n            maxX = Math.max(maxX, point.x);\n            maxY = Math.max(maxY, point.y);\n        }\n        return {\n            height: maxY - minY,\n            width: maxX - minX,\n            x: (minX + maxX) / 2,\n            y: (minY + maxY) / 2,\n        };\n    }\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n    function rasterizePolygonToMask(points, dimensions) {\n        const data = createEmptyMask(dimensions);\n        if (points.length < 3) {\n            return data;\n        }\n        const bounds = centerRectToTopLeftRect(getPointsRect(points));\n        const startY = Math.max(0, Math.floor(bounds.y));\n        const endY = Math.min(dimensions.height - 1, Math.ceil(bounds.y + bounds.height));\n        for (let y = startY; y <= endY; y += 1) {\n            const scanY = y + 0.5;\n            const intersections = [];\n            for (let index = 0; index < points.length; index += 1) {\n                const current = points[index];\n                const next = points[(index + 1) % points.length];\n                if ((current.y <= scanY && next.y > scanY) ||\n                    (next.y <= scanY && current.y > scanY)) {\n                    const ratio = (scanY - current.y) / (next.y - current.y);\n                    intersections.push(current.x + ratio * (next.x - current.x));\n                }\n            }\n            intersections.sort((left, right) => left - right);\n            for (let index = 0; index < intersections.length - 1; index += 2) {\n                const left = Math.max(0, Math.round(intersections[index]));\n                const right = Math.min(dimensions.width, Math.round(intersections[index + 1]));\n                for (let x = left; x < right; x += 1) {\n                    data[y * dimensions.width + x] = 1;\n                }\n            }\n        }\n        return data;\n    }\n    function createEmptyMask(dimensions) {\n        if (!Number.isInteger(dimensions.width) ||\n            dimensions.width <= 0 ||\n            !Number.isInteger(dimensions.height) ||\n            dimensions.height <= 0) {\n            throw new Error(\"Media dimensions must be positive integers.\");\n        }\n        return new Uint8Array(dimensions.width * dimensions.height);\n    }\n\n    /**\n     * Palette slots an id raster can name, one of them the background. A GLSL\n     * fragment stage is guaranteed only 224 uniform vectors, and a palette entry\n     * costs 2.25 of them, so this stays a multiple of four and well inside that\n     * budget; past it a frame draws from the RGBA composite instead.\n     */\n    const MAX_ID_MASK_PALETTE_ENTRIES = 80;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions, options = {}) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const maskWidth = Math.max(...instructions.map(({ mask }) => mask.width));\n        const maskHeight = Math.max(...instructions.map(({ mask }) => mask.height));\n        const width = resolveRasterWidth(maskWidth, options.maxWidth);\n        const height = width === maskWidth\n            ? maskHeight\n            : Math.max(1, Math.round((width * maskHeight) / maskWidth));\n        const strokeScale = width / maskWidth;\n        const scaledAxes = width === maskWidth\n            ? undefined\n            : createScaledMaskAxes({ height, maskHeight, maskWidth, width });\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        const fillPalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokePalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokeWidths = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4));\n        let hasStroke = false;\n        let maxStrokeWidth = 0;\n        for (const instruction of instructions) {\n            const detectionMaskId = instruction.detectionIndex + 1;\n            if (detectionMaskId <= 0 ||\n                detectionMaskId >= MAX_ID_MASK_PALETTE_ENTRIES) {\n                return undefined;\n            }\n            writePaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);\n            if (instruction.stroke && instruction.stroke.width > 0) {\n                const strokeWidth = Math.min(resolveStrokeTexels(instruction.stroke.width, strokeScale), MAX_ID_MASK_STROKE_WIDTH);\n                hasStroke = true;\n                strokeWidths[detectionMaskId] = strokeWidth;\n                maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);\n                writePaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);\n            }\n            if (scaledAxes) {\n                writeScaledMaskRuns(data, scaledAxes, instruction.mask, detectionMaskId);\n            }\n            else {\n                writeMaskRuns(data, width, instruction.mask, detectionMaskId);\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\n    }\n    /**\n     * Compressed RLE counts runs down each column in turn, so a foreground run is\n     * a contiguous walk down one column that wraps into the next.\n     */\n    function writeMaskRuns(data, frameWidth, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let frameOffset = y * frameWidth + x;\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[frameOffset] = detectionMaskId;\n                y += 1;\n                frameOffset += frameWidth;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    frameOffset = x;\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    /**\n     * The scaled twin of writeMaskRuns. Every source pixel marks the texel it lands\n     * in, so a mask keeps every part of itself the smaller raster can hold and\n     * gains up to a texel at its edges.\n     */\n    function writeScaledMaskRuns(data, axes, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let column = axes.columns[x];\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[axes.rows[y] + column] = detectionMaskId;\n                y += 1;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    column = axes.columns[x];\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    function resolveRasterWidth(maskWidth, maxWidth) {\n        return maxWidth !== undefined && maxWidth > 0 && maxWidth < maskWidth\n            ? Math.max(1, Math.floor(maxWidth))\n            : maskWidth;\n    }\n    /**\n     * A stroke is measured in texels of the raster it is drawn on, so a coarser\n     * raster measures it in coarser texels. A stroke of a texel or more keeps at\n     * least one, the thinnest line the shader can draw; a narrower one keeps its\n     * own width, which the shader draws as an inner boundary at any scale.\n     */\n    function resolveStrokeTexels(strokeWidth, scale) {\n        return Math.max(strokeWidth * scale, Math.min(strokeWidth, 1));\n    }\n    function createScaledMaskAxes(frame) {\n        return {\n            columns: createMaskAxisMap(frame.maskWidth, frame.width, 1),\n            rows: createMaskAxisMap(frame.maskHeight, frame.height, frame.width),\n        };\n    }\n    /** Rows hold their destination offset, so writing a run is two lookups. */\n    function createMaskAxisMap(sourceLength, targetLength, stride) {\n        const map = new Int32Array(sourceLength);\n        const scale = targetLength / sourceLength;\n        for (let index = 0; index < sourceLength; index += 1) {\n            map[index] = Math.min(targetLength - 1, Math.floor(index * scale)) * stride;\n        }\n        return map;\n    }\n    function writePaletteEntry(palette, id, color, alpha) {\n        const offset = id * 4;\n        palette[offset] = ((color >> 16) & 0xff) / 255;\n        palette[offset + 1] = ((color >> 8) & 0xff) / 255;\n        palette[offset + 2] = (color & 0xff) / 255;\n        palette[offset + 3] = Math.max(0, Math.min(alpha, 1));\n    }\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read at all. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, which the detection gate does and the\n     * render-preparation gate does not.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n        /** Playback waits to begin; frames after that are not held. */\n        PlaybackGateReach[\"StartOfPlayback\"] = \"startOfPlayback\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    /** Builds compact, independent alpha crops so overlapping masks stay exact. */\n    function createRegionMaskCoverageFrame(instructions) {\n        const entries = [];\n        for (const instruction of instructions) {\n            if (!instruction.regionCoverageMask) {\n                continue;\n            }\n            const entry = cropCoverageMask(instruction.detectionIndex, decodeCompressedRleMask(instruction.regionCoverageMask));\n            if (entry) {\n                entries.push(entry);\n            }\n        }\n        return entries.length > 0 ? { entries } : undefined;\n    }\n    function cropCoverageMask(detectionIndex, decodedMask) {\n        let minX = decodedMask.width;\n        let minY = decodedMask.height;\n        let maxX = -1;\n        let maxY = -1;\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                minX = Math.min(minX, x);\n                minY = Math.min(minY, y);\n                maxX = Math.max(maxX, x);\n                maxY = Math.max(maxY, y);\n            }\n        }\n        if (maxX < minX || maxY < minY) {\n            return undefined;\n        }\n        const width = maxX - minX + 1;\n        const height = maxY - minY + 1;\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        for (let y = minY; y <= maxY; y += 1) {\n            for (let x = minX; x <= maxX; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                data[(y - minY) * width + (x - minX)] = 255;\n            }\n        }\n        return { data, detectionIndex, height, width, x: minX, y: minY };\n    }\n    function compositeMaskFrame(instructions) {\n        const maskInstructions = materializeMaskInstructions(instructions);\n        if (maskInstructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...maskInstructions.map(({ mask }) => mask.width));\n        const height = Math.max(...maskInstructions.map(({ mask }) => mask.height));\n        const data = new Uint8ClampedArray(new ArrayBuffer(width * height * 4));\n        for (const instruction of maskInstructions) {\n            compositeInstruction(data, width, instruction);\n        }\n        return { data, height, width };\n    }\n    function createIdMaskRasterFrame(instructions, maxRasterWidth) {\n        try {\n            return createIdMaskFrame(materializeMaskInstructions(instructions), {\n                maxWidth: maxRasterWidth,\n            });\n        }\n        catch {\n            // The id raster is the fast path, not the only one: answering with nothing\n            // puts the caller on the RGBA composite, which draws the same picture.\n            return undefined;\n        }\n    }\n    function createIdMaskPlane(instructions, maxRasterWidth) {\n        const frame = createIdMaskRasterFrame(instructions, maxRasterWidth);\n        return frame\n            ? { data: frame.data, height: frame.height, width: frame.width }\n            : undefined;\n    }\n    function compositeInstruction(rgba, canvasWidth, instruction) {\n        const decodedMask = decodeCompressedRleMask(instruction.mask);\n        const fill = resolveRgbaColor(instruction.color, instruction.alpha);\n        compositeMaskFill(rgba, canvasWidth, decodedMask, fill);\n        if (instruction.stroke) {\n            compositeMaskStroke(rgba, canvasWidth, decodedMask, instruction.stroke);\n        }\n    }\n    function materializeMaskInstructions(instructions) {\n        return instructions\n            .filter((instruction) => instruction.visible !== false)\n            .map((instruction) => {\n            if (instruction.mask) {\n                return instruction;\n            }\n            const { height, points, width } = instruction.polygon;\n            return {\n                alpha: instruction.alpha,\n                color: instruction.color,\n                detectionIndex: instruction.detectionIndex,\n                mask: encodeBinaryMask(rasterizePolygonToMask(points, { height, width }), width, height),\n                stroke: instruction.stroke,\n            };\n        });\n    }\n    function compositeMaskFill(rgba, canvasWidth, decodedMask, fill) {\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                const maskOffset = y * decodedMask.width + x;\n                if (!decodedMask.data[maskOffset]) {\n                    continue;\n                }\n                writePixel(rgba, canvasWidth, x, y, fill);\n            }\n        }\n    }\n    function compositeMaskStroke(rgba, canvasWidth, decodedMask, stroke) {\n        const width = Math.round(stroke.width);\n        if (width <= 0) {\n            return;\n        }\n        const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                if (!isMaskPixel(decodedMask, x, y) ||\n                    !isBoundaryPixel(decodedMask, x, y)) {\n                    continue;\n                }\n                for (let offsetY = -width; offsetY <= width; offsetY += 1) {\n                    for (let offsetX = -width; offsetX <= width; offsetX += 1) {\n                        const strokeX = x + offsetX;\n                        const strokeY = y + offsetY;\n                        if (isOutsideMaskBounds(decodedMask, strokeX, strokeY) ||\n                            isMaskPixel(decodedMask, strokeX, strokeY)) {\n                            continue;\n                        }\n                        writePixel(rgba, canvasWidth, strokeX, strokeY, strokeColor);\n                    }\n                }\n            }\n        }\n    }\n    function isBoundaryPixel(mask, x, y) {\n        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {\n            for (let offsetX = -1; offsetX <= 1; offsetX += 1) {\n                if (offsetX === 0 && offsetY === 0) {\n                    continue;\n                }\n                const neighborX = x + offsetX;\n                const neighborY = y + offsetY;\n                if (isOutsideMaskBounds(mask, neighborX, neighborY) ||\n                    !isMaskPixel(mask, neighborX, neighborY)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    function isMaskPixel(mask, x, y) {\n        return mask.data[y * mask.width + x] === 1;\n    }\n    function isOutsideMaskBounds(mask, x, y) {\n        return x < 0 || y < 0 || x >= mask.width || y >= mask.height;\n    }\n    function resolveRgbaColor(color, alpha) {\n        return {\n            alpha: Math.round(Math.max(0, Math.min(alpha, 1)) * 255),\n            blue: color & 0xff,\n            green: (color >> 8) & 0xff,\n            red: (color >> 16) & 0xff,\n        };\n    }\n    function writePixel(rgba, canvasWidth, x, y, color) {\n        const rgbaOffset = (y * canvasWidth + x) * 4;\n        rgba[rgbaOffset] = color.red;\n        rgba[rgbaOffset + 1] = color.green;\n        rgba[rgbaOffset + 2] = color.blue;\n        rgba[rgbaOffset + 3] = color.alpha;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"IdMask\"] = \"idMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\n    /**\n     * How an id raster is laid out for the texture it is uploaded into. WebGPU\n     * takes any bytesPerRow, so ids go up one byte per pixel. WebGL aligns every\n     * uploaded row to four bytes and rejects a single-channel upload whose width\n     * is not a multiple of four, which is what the four-channel layout is for.\n     */\n    var IdMaskTextureFormat;\n    (function (IdMaskTextureFormat) {\n        IdMaskTextureFormat[\"R8\"] = \"r8unorm\";\n        IdMaskTextureFormat[\"Rgba8\"] = \"rgba8unorm\";\n    })(IdMaskTextureFormat || (IdMaskTextureFormat = {}));\n\n    var MaskPreparationWorkerMessageType;\n    (function (MaskPreparationWorkerMessageType) {\n        MaskPreparationWorkerMessageType[\"Complete\"] = \"complete\";\n        MaskPreparationWorkerMessageType[\"Empty\"] = \"empty\";\n        MaskPreparationWorkerMessageType[\"Error\"] = \"error\";\n        MaskPreparationWorkerMessageType[\"Prepare\"] = \"prepare\";\n    })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));\n\n    const workerScope = globalThis;\n    workerScope.addEventListener(\"message\", (event) => {\n        const message = event.data;\n        if (message.type !== MaskPreparationWorkerMessageType.Prepare) {\n            return;\n        }\n        prepareMaskFrame(message);\n    });\n    function prepareMaskFrame(message) {\n        try {\n            const regionMaskCoverage = createRegionMaskCoverageFrame(message.job.instructions);\n            const coverageTransfers = getRegionMaskCoverageTransfers(regionMaskCoverage);\n            const idMaskFrame = createIdMaskRasterFrame(message.job.instructions, message.job.maxRasterWidth);\n            if (idMaskFrame) {\n                workerScope.postMessage({\n                    artifactKind: PreparedMaskFrameKind.IdMask,\n                    fillPalette: idMaskFrame.fillPalette,\n                    hasStroke: idMaskFrame.hasStroke,\n                    height: idMaskFrame.height,\n                    key: message.job.key,\n                    maxStrokeWidth: idMaskFrame.maxStrokeWidth,\n                    raster: idMaskFrame.data,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    strokePalette: idMaskFrame.strokePalette,\n                    strokeWidths: idMaskFrame.strokeWidths,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                    width: idMaskFrame.width,\n                }, [\n                    idMaskFrame.data.buffer,\n                    idMaskFrame.fillPalette.buffer,\n                    idMaskFrame.strokePalette.buffer,\n                    idMaskFrame.strokeWidths.buffer,\n                    ...coverageTransfers,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame && !regionMaskCoverage) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const preparedPixels = compositedFrame ?? createTransparentCoverageCarrier();\n            const imageData = new ImageData(preparedPixels.data, preparedPixels.width, preparedPixels.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            const idMaskPlane = createIdMaskPlane(message.job.instructions, message.job.maxRasterWidth);\n            const idMaskTransfers = idMaskPlane ? [idMaskPlane.data.buffer] : [];\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    idMaskPlane,\n                    imageBitmap,\n                    key: message.job.key,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [imageBitmap, ...idMaskTransfers, ...coverageTransfers]);\n                return;\n            }\n            workerScope.postMessage({\n                idMaskPlane,\n                imageData,\n                key: message.job.key,\n                regionMaskCoverage,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [imageData.data.buffer, ...idMaskTransfers, ...coverageTransfers]);\n        }\n        catch (error) {\n            workerScope.postMessage({\n                error: error instanceof Error\n                    ? error.message\n                    : \"Unable to prepare mask frame.\",\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Error,\n            });\n        }\n    }\n    /**\n     * A frame that carries only region coverage has nothing to composite, and the\n     * RGBA branch still has to produce an artifact for the coverage to ride on.\n     */\n    function createTransparentCoverageCarrier() {\n        return {\n            data: new Uint8ClampedArray(new ArrayBuffer(4)),\n            height: 1,\n            width: 1,\n        };\n    }\n    function getRegionMaskCoverageTransfers(coverage) {\n        return coverage?.entries.map(({ data }) => data.buffer) ?? [];\n    }\n    function createImageBitmapFromImageData(imageData) {\n        if (typeof OffscreenCanvas === \"undefined\") {\n            return null;\n        }\n        const canvas = new OffscreenCanvas(imageData.width, imageData.height);\n        const context = canvas.getContext(\"2d\");\n        if (!context) {\n            return null;\n        }\n        context.putImageData(imageData, 0, 0);\n        return canvas.transferToImageBitmap();\n    }\n\n})();";
+const EMBEDDED_MASK_PREPARATION_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n    function decodeCompressedRleMask(mask) {\n        if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {\n            throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);\n        }\n        const data = new Uint8Array(mask.width * mask.height);\n        const counts = decodeCompressedRleCounts(mask.counts);\n        let offset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            const isForeground = index % 2 === 1;\n            if (isForeground) {\n                for (let runOffset = 0; runOffset < runLength; runOffset += 1) {\n                    const maskOffset = offset + runOffset;\n                    const x = Math.floor(maskOffset / mask.height);\n                    const y = maskOffset % mask.height;\n                    const rowMajorOffset = y * mask.width + x;\n                    if (rowMajorOffset < data.length) {\n                        data[rowMajorOffset] = 1;\n                    }\n                }\n            }\n            offset += runLength;\n        }\n        return {\n            data,\n            height: mask.height,\n            width: mask.width,\n        };\n    }\n    function decodeCompressedRleCounts(counts) {\n        const decoded = [];\n        let index = 0;\n        while (index < counts.length) {\n            let value = 0;\n            let shift = 0;\n            let charCode;\n            do {\n                charCode = counts.charCodeAt(index) - 48;\n                index += 1;\n                value |= (charCode & 0x1f) << shift;\n                shift += 5;\n            } while (charCode & 0x20);\n            if (charCode & 0x10) {\n                value |= -1 << shift;\n            }\n            if (decoded.length > 2) {\n                value += decoded[decoded.length - 2] ?? 0;\n            }\n            decoded.push(value);\n        }\n        return decoded;\n    }\n    function encodeCompressedRleCounts(counts) {\n        return counts\n            .map((count, index) => {\n            let value = index > 2 ? count - counts[index - 2] : count;\n            let encoded = \"\";\n            let more = true;\n            while (more) {\n                let charCode = value & 0x1f;\n                value >>= 5;\n                more = !((value === 0 && (charCode & 0x10) === 0) ||\n                    (value === -1 && (charCode & 0x10) !== 0));\n                if (more) {\n                    charCode |= 0x20;\n                }\n                encoded += String.fromCharCode(charCode + 48);\n            }\n            return encoded;\n        })\n            .join(\"\");\n    }\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n    function encodeBinaryMask(data, width, height) {\n        assertMaskDimensions(data, width, height);\n        const runs = [];\n        let currentValue = 0;\n        let runLength = 0;\n        for (let x = 0; x < width; x += 1) {\n            for (let y = 0; y < height; y += 1) {\n                const value = data[y * width + x] ? 1 : 0;\n                if (value === currentValue) {\n                    runLength += 1;\n                }\n                else {\n                    runs.push(runLength);\n                    currentValue = value;\n                    runLength = 1;\n                }\n            }\n        }\n        runs.push(runLength);\n        return {\n            counts: encodeCompressedRleCounts(runs),\n            encoding: DetectionMaskEncoding.CompressedRle,\n            height,\n            width,\n        };\n    }\n    function assertMaskSize(width, height) {\n        if (!Number.isInteger(width) || width <= 0) {\n            throw new Error(\"Mask width must be a positive integer.\");\n        }\n        if (!Number.isInteger(height) || height <= 0) {\n            throw new Error(\"Mask height must be a positive integer.\");\n        }\n    }\n    function assertMaskDimensions(data, width, height) {\n        assertMaskSize(width, height);\n        if (data.length !== width * height) {\n            throw new Error(\"Mask data length must equal width * height.\");\n        }\n    }\n\n    function centerRectToTopLeftRect(rect) {\n        return {\n            height: rect.height,\n            width: rect.width,\n            x: rect.x - rect.width / 2,\n            y: rect.y - rect.height / 2,\n        };\n    }\n    function getPointsRect(points) {\n        if (points.length === 0) {\n            return undefined;\n        }\n        let minX = Number.POSITIVE_INFINITY;\n        let minY = Number.POSITIVE_INFINITY;\n        let maxX = Number.NEGATIVE_INFINITY;\n        let maxY = Number.NEGATIVE_INFINITY;\n        for (const point of points) {\n            minX = Math.min(minX, point.x);\n            minY = Math.min(minY, point.y);\n            maxX = Math.max(maxX, point.x);\n            maxY = Math.max(maxY, point.y);\n        }\n        return {\n            height: maxY - minY,\n            width: maxX - minX,\n            x: (minX + maxX) / 2,\n            y: (minY + maxY) / 2,\n        };\n    }\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n    function rasterizePolygonToMask(points, dimensions) {\n        const data = createEmptyMask(dimensions);\n        if (points.length < 3) {\n            return data;\n        }\n        const bounds = centerRectToTopLeftRect(getPointsRect(points));\n        const startY = Math.max(0, Math.floor(bounds.y));\n        const endY = Math.min(dimensions.height - 1, Math.ceil(bounds.y + bounds.height));\n        for (let y = startY; y <= endY; y += 1) {\n            const scanY = y + 0.5;\n            const intersections = [];\n            for (let index = 0; index < points.length; index += 1) {\n                const current = points[index];\n                const next = points[(index + 1) % points.length];\n                if ((current.y <= scanY && next.y > scanY) ||\n                    (next.y <= scanY && current.y > scanY)) {\n                    const ratio = (scanY - current.y) / (next.y - current.y);\n                    intersections.push(current.x + ratio * (next.x - current.x));\n                }\n            }\n            intersections.sort((left, right) => left - right);\n            for (let index = 0; index < intersections.length - 1; index += 2) {\n                const left = Math.max(0, Math.round(intersections[index]));\n                const right = Math.min(dimensions.width, Math.round(intersections[index + 1]));\n                for (let x = left; x < right; x += 1) {\n                    data[y * dimensions.width + x] = 1;\n                }\n            }\n        }\n        return data;\n    }\n    function createEmptyMask(dimensions) {\n        if (!Number.isInteger(dimensions.width) ||\n            dimensions.width <= 0 ||\n            !Number.isInteger(dimensions.height) ||\n            dimensions.height <= 0) {\n            throw new Error(\"Media dimensions must be positive integers.\");\n        }\n        return new Uint8Array(dimensions.width * dimensions.height);\n    }\n\n    /**\n     * Palette slots an id raster can name, one of them the background. A GLSL\n     * fragment stage is guaranteed only 224 uniform vectors, and a palette entry\n     * costs 2.25 of them, so this stays a multiple of four and well inside that\n     * budget; past it a frame draws from the RGBA composite instead.\n     */\n    const MAX_ID_MASK_PALETTE_ENTRIES = 80;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions, options = {}) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const maskWidth = Math.max(...instructions.map(({ mask }) => mask.width));\n        const maskHeight = Math.max(...instructions.map(({ mask }) => mask.height));\n        const width = resolveRasterWidth(maskWidth, options.maxWidth);\n        const height = width === maskWidth\n            ? maskHeight\n            : Math.max(1, Math.round((width * maskHeight) / maskWidth));\n        const scaledAxes = width === maskWidth\n            ? undefined\n            : createScaledMaskAxes({ height, maskHeight, maskWidth, width });\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        const fillPalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokePalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokeWidths = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4));\n        let hasStroke = false;\n        let maxStrokeWidth = 0;\n        for (const instruction of instructions) {\n            const detectionMaskId = resolveIdMaskPaletteId(instruction.detectionIndex);\n            if (detectionMaskId === undefined) {\n                return undefined;\n            }\n            writeIdMaskPaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);\n            if (instruction.stroke && instruction.stroke.width > 0) {\n                const strokeWidth = resolveIdMaskStrokeTexels(instruction.stroke.width, maskWidth, width);\n                hasStroke = true;\n                strokeWidths[detectionMaskId] = strokeWidth;\n                maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);\n                writeIdMaskPaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);\n            }\n            if (scaledAxes) {\n                writeScaledMaskRuns(data, scaledAxes, instruction.mask, detectionMaskId);\n            }\n            else {\n                writeMaskRuns(data, width, instruction.mask, detectionMaskId);\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            sourceWidth: maskWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\n    }\n    /**\n     * Compressed RLE counts runs down each column in turn, so a foreground run is\n     * a contiguous walk down one column that wraps into the next.\n     */\n    function writeMaskRuns(data, frameWidth, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let frameOffset = y * frameWidth + x;\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[frameOffset] = detectionMaskId;\n                y += 1;\n                frameOffset += frameWidth;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    frameOffset = x;\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    /**\n     * The scaled twin of writeMaskRuns. Every source pixel marks the texel it lands\n     * in, so a mask keeps every part of itself the smaller raster can hold and\n     * gains up to a texel at its edges.\n     */\n    function writeScaledMaskRuns(data, axes, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let column = axes.columns[x];\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[axes.rows[y] + column] = detectionMaskId;\n                y += 1;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    column = axes.columns[x];\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    function resolveRasterWidth(maskWidth, maxWidth) {\n        return maxWidth !== undefined && maxWidth > 0 && maxWidth < maskWidth\n            ? Math.max(1, Math.floor(maxWidth))\n            : maskWidth;\n    }\n    /**\n     * A stroke is measured in texels of the raster it is drawn on, so a coarser\n     * raster measures it in coarser texels. A stroke of a texel or more keeps at\n     * least one, the thinnest line the shader can draw; a narrower one keeps its\n     * own width, which the shader draws as an inner boundary at any scale. The\n     * ceiling is the widest neighbourhood the shaders scan, so a wider stroke would\n     * be drawn at the ceiling anyway and every layer drawing the same annotation\n     * has to arrive at the same width.\n     */\n    function resolveIdMaskStrokeTexels(strokeWidth, maskWidth, rasterWidth) {\n        const scale = maskWidth > 0 ? rasterWidth / maskWidth : 1;\n        return Math.min(Math.max(strokeWidth * scale, Math.min(strokeWidth, 1)), MAX_ID_MASK_STROKE_WIDTH);\n    }\n    function createScaledMaskAxes(frame) {\n        return {\n            columns: createMaskAxisMap(frame.maskWidth, frame.width, 1),\n            rows: createMaskAxisMap(frame.maskHeight, frame.height, frame.width),\n        };\n    }\n    /** Rows hold their destination offset, so writing a run is two lookups. */\n    function createMaskAxisMap(sourceLength, targetLength, stride) {\n        const map = new Int32Array(sourceLength);\n        const scale = targetLength / sourceLength;\n        for (let index = 0; index < sourceLength; index += 1) {\n            map[index] = Math.min(targetLength - 1, Math.floor(index * scale)) * stride;\n        }\n        return map;\n    }\n    /**\n     * The palette slot a detection index names, or undefined when the palette has\n     * no slot for it. Slot zero is the background, so the ids start at one and the\n     * last detection the palette can name sits one index below the last slot.\n     */\n    function resolveIdMaskPaletteId(detectionIndex) {\n        const detectionMaskId = detectionIndex + 1;\n        return detectionMaskId > 0 && detectionMaskId < MAX_ID_MASK_PALETTE_ENTRIES\n            ? detectionMaskId\n            : undefined;\n    }\n    function writeIdMaskPaletteEntry(palette, detectionMaskId, color, alpha) {\n        const offset = detectionMaskId * 4;\n        palette[offset] = ((color >> 16) & 0xff) / 255;\n        palette[offset + 1] = ((color >> 8) & 0xff) / 255;\n        palette[offset + 2] = (color & 0xff) / 255;\n        palette[offset + 3] = Math.max(0, Math.min(alpha, 1));\n    }\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read, or was refused before any read. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, and a gate that stops one has to bound its own wait\n     * or a producer nothing answers for never runs again.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        /**\n         * The picture is waiting on media the source has not handed over yet, which\n         * is the bytes and their decode rather than anything downstream of them.\n         * `PlaybackBuffering` is what a transport reports once it has already\n         * stopped; this is reported from the read itself, including the reads a seek\n         * makes while the transport still reads as paused.\n         */\n        MediaSessionActivityKind[\"MediaSourceReading\"] = \"mediaSourceReading\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        /**\n         * The render-preparation gate held the picture for artifacts that never\n         * arrived and let it go. Nothing is blocked: the frames reaching the screen\n         * are the ones whose artifacts were given up on. What is waited on is\n         * preparation finishing another frame, which is what lets the gate hold the\n         * picture again; `RenderPreparing` covers the holds that are running.\n         */\n        MediaSessionActivityKind[\"RenderPreparationAbandoned\"] = \"renderPreparationAbandoned\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    /** Builds compact, independent alpha crops so overlapping masks stay exact. */\n    function createRegionMaskCoverageFrame(instructions) {\n        const entries = [];\n        for (const instruction of instructions) {\n            if (!instruction.regionCoverageMask) {\n                continue;\n            }\n            const entry = cropCoverageMask(instruction.detectionIndex, decodeCompressedRleMask(instruction.regionCoverageMask));\n            if (entry) {\n                entries.push(entry);\n            }\n        }\n        return entries.length > 0 ? { entries } : undefined;\n    }\n    function cropCoverageMask(detectionIndex, decodedMask) {\n        let minX = decodedMask.width;\n        let minY = decodedMask.height;\n        let maxX = -1;\n        let maxY = -1;\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                minX = Math.min(minX, x);\n                minY = Math.min(minY, y);\n                maxX = Math.max(maxX, x);\n                maxY = Math.max(maxY, y);\n            }\n        }\n        if (maxX < minX || maxY < minY) {\n            return undefined;\n        }\n        const width = maxX - minX + 1;\n        const height = maxY - minY + 1;\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        for (let y = minY; y <= maxY; y += 1) {\n            for (let x = minX; x <= maxX; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                data[(y - minY) * width + (x - minX)] = 255;\n            }\n        }\n        return { data, detectionIndex, height, width, x: minX, y: minY };\n    }\n    function compositeMaskFrame(instructions) {\n        const maskInstructions = materializeMaskInstructions(instructions);\n        if (maskInstructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...maskInstructions.map(({ mask }) => mask.width));\n        const height = Math.max(...maskInstructions.map(({ mask }) => mask.height));\n        const data = new Uint8ClampedArray(new ArrayBuffer(width * height * 4));\n        for (const instruction of maskInstructions) {\n            compositeInstruction(data, width, instruction);\n        }\n        return { data, height, width };\n    }\n    function createIdMaskRasterFrame(instructions, maxRasterWidth) {\n        try {\n            return createIdMaskFrame(materializeMaskInstructions(instructions), {\n                maxWidth: maxRasterWidth,\n            });\n        }\n        catch {\n            // The id raster is the fast path, not the only one: answering with nothing\n            // puts the caller on the RGBA composite, which draws the same picture.\n            return undefined;\n        }\n    }\n    /**\n     * Whether the palette has a slot for every detection this frame masks. An id\n     * names a detection by its index in the frame, so one masked detection past the\n     * last slot leaves the whole frame without an id raster however few masks it\n     * carries.\n     */\n    function canIdMaskPaletteNameFrame(instructions) {\n        return instructions.every((instruction) => instruction.visible === false ||\n            resolveIdMaskPaletteId(instruction.detectionIndex) !== undefined);\n    }\n    function createIdMaskPlane(instructions, maxRasterWidth) {\n        // The plane carries the ids a failed cook could not. A frame the palette\n        // cannot name has none to carry, and cooking it again reaches the same\n        // refusal after rasterizing every mask a second time.\n        if (!canIdMaskPaletteNameFrame(instructions)) {\n            return undefined;\n        }\n        const frame = createIdMaskRasterFrame(instructions, maxRasterWidth);\n        return frame\n            ? { data: frame.data, height: frame.height, width: frame.width }\n            : undefined;\n    }\n    function compositeInstruction(rgba, canvasWidth, instruction) {\n        const fill = resolveRgbaColor(instruction.color, instruction.alpha);\n        const bounds = compositeMaskFill(rgba, canvasWidth, instruction.mask, fill);\n        if (instruction.stroke && bounds) {\n            compositeMaskStroke(rgba, canvasWidth, decodeCompressedRleMask(instruction.mask), bounds, instruction.stroke);\n        }\n    }\n    function materializeMaskInstructions(instructions) {\n        return instructions\n            .filter((instruction) => instruction.visible !== false)\n            .map((instruction) => {\n            if (instruction.mask) {\n                return instruction;\n            }\n            const { height, points, width } = instruction.polygon;\n            return {\n                alpha: instruction.alpha,\n                color: instruction.color,\n                detectionIndex: instruction.detectionIndex,\n                mask: encodeBinaryMask(rasterizePolygonToMask(points, { height, width }), width, height),\n                stroke: instruction.stroke,\n            };\n        });\n    }\n    /**\n     * Compressed RLE counts runs down each column in turn, so a foreground run is\n     * a contiguous walk down one column that wraps into the next.\n     */\n    function compositeMaskFill(rgba, canvasWidth, mask, fill) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        const maskArea = maskWidth * maskHeight;\n        let maskOffset = 0;\n        let minX = maskWidth;\n        let minY = maskHeight;\n        let maxX = -1;\n        let maxY = -1;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let columnX = Math.floor(maskOffset / maskHeight);\n            let columnY = maskOffset - columnX * maskHeight;\n            for (let step = 0; step < runLength; step += 1) {\n                // A run can outlast the columns the mask has; the pixel it then names\n                // is wherever that column-major offset lands when read back row-major.\n                const rowMajorOffset = columnY * maskWidth + columnX;\n                if (rowMajorOffset < maskArea) {\n                    const x = rowMajorOffset % maskWidth;\n                    const y = (rowMajorOffset - x) / maskWidth;\n                    writePixel(rgba, canvasWidth, x, y, fill);\n                    minX = Math.min(minX, x);\n                    minY = Math.min(minY, y);\n                    maxX = Math.max(maxX, x);\n                    maxY = Math.max(maxY, y);\n                }\n                columnY += 1;\n                if (columnY === maskHeight) {\n                    columnY = 0;\n                    columnX += 1;\n                }\n            }\n            maskOffset += runLength;\n        }\n        return maxX < minX || maxY < minY ? undefined : { maxX, maxY, minX, minY };\n    }\n    function compositeMaskStroke(rgba, canvasWidth, decodedMask, bounds, stroke) {\n        const width = Math.round(stroke.width);\n        if (width <= 0) {\n            return;\n        }\n        const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);\n        for (let y = bounds.minY; y <= bounds.maxY; y += 1) {\n            for (let x = bounds.minX; x <= bounds.maxX; x += 1) {\n                if (!isMaskPixel(decodedMask, x, y) ||\n                    !isBoundaryPixel(decodedMask, x, y)) {\n                    continue;\n                }\n                for (let offsetY = -width; offsetY <= width; offsetY += 1) {\n                    for (let offsetX = -width; offsetX <= width; offsetX += 1) {\n                        const strokeX = x + offsetX;\n                        const strokeY = y + offsetY;\n                        if (isOutsideMaskBounds(decodedMask, strokeX, strokeY) ||\n                            isMaskPixel(decodedMask, strokeX, strokeY)) {\n                            continue;\n                        }\n                        writePixel(rgba, canvasWidth, strokeX, strokeY, strokeColor);\n                    }\n                }\n            }\n        }\n    }\n    function isBoundaryPixel(mask, x, y) {\n        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {\n            for (let offsetX = -1; offsetX <= 1; offsetX += 1) {\n                if (offsetX === 0 && offsetY === 0) {\n                    continue;\n                }\n                const neighborX = x + offsetX;\n                const neighborY = y + offsetY;\n                if (isOutsideMaskBounds(mask, neighborX, neighborY) ||\n                    !isMaskPixel(mask, neighborX, neighborY)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    function isMaskPixel(mask, x, y) {\n        return mask.data[y * mask.width + x] === 1;\n    }\n    function isOutsideMaskBounds(mask, x, y) {\n        return x < 0 || y < 0 || x >= mask.width || y >= mask.height;\n    }\n    function resolveRgbaColor(color, alpha) {\n        return {\n            alpha: Math.round(Math.max(0, Math.min(alpha, 1)) * 255),\n            blue: color & 0xff,\n            green: (color >> 8) & 0xff,\n            red: (color >> 16) & 0xff,\n        };\n    }\n    function writePixel(rgba, canvasWidth, x, y, color) {\n        const rgbaOffset = (y * canvasWidth + x) * 4;\n        rgba[rgbaOffset] = color.red;\n        rgba[rgbaOffset + 1] = color.green;\n        rgba[rgbaOffset + 2] = color.blue;\n        rgba[rgbaOffset + 3] = color.alpha;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"IdMask\"] = \"idMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\n    /**\n     * How an id raster is laid out for the texture it is uploaded into. WebGPU\n     * takes any bytesPerRow, so ids go up one byte per pixel. WebGL aligns every\n     * uploaded row to four bytes and rejects a single-channel upload whose width\n     * is not a multiple of four, which is what the four-channel layout is for.\n     */\n    var IdMaskTextureFormat;\n    (function (IdMaskTextureFormat) {\n        IdMaskTextureFormat[\"R8\"] = \"r8unorm\";\n        IdMaskTextureFormat[\"Rgba8\"] = \"rgba8unorm\";\n    })(IdMaskTextureFormat || (IdMaskTextureFormat = {}));\n\n    var MaskPreparationWorkerMessageType;\n    (function (MaskPreparationWorkerMessageType) {\n        MaskPreparationWorkerMessageType[\"Complete\"] = \"complete\";\n        MaskPreparationWorkerMessageType[\"Empty\"] = \"empty\";\n        MaskPreparationWorkerMessageType[\"Error\"] = \"error\";\n        MaskPreparationWorkerMessageType[\"Prepare\"] = \"prepare\";\n    })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));\n\n    const workerScope = globalThis;\n    workerScope.addEventListener(\"message\", (event) => {\n        const message = event.data;\n        if (message.type !== MaskPreparationWorkerMessageType.Prepare) {\n            return;\n        }\n        prepareMaskFrame(message);\n    });\n    function prepareMaskFrame(message) {\n        try {\n            const regionMaskCoverage = createRegionMaskCoverageFrame(message.job.instructions);\n            const coverageTransfers = getRegionMaskCoverageTransfers(regionMaskCoverage);\n            const idMaskFrame = createIdMaskRasterFrame(message.job.instructions, message.job.maxRasterWidth);\n            if (idMaskFrame) {\n                workerScope.postMessage({\n                    artifactKind: PreparedMaskFrameKind.IdMask,\n                    fillPalette: idMaskFrame.fillPalette,\n                    hasStroke: idMaskFrame.hasStroke,\n                    height: idMaskFrame.height,\n                    key: message.job.key,\n                    maxStrokeWidth: idMaskFrame.maxStrokeWidth,\n                    raster: idMaskFrame.data,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    sourceWidth: idMaskFrame.sourceWidth,\n                    strokePalette: idMaskFrame.strokePalette,\n                    strokeWidths: idMaskFrame.strokeWidths,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                    width: idMaskFrame.width,\n                }, [\n                    idMaskFrame.data.buffer,\n                    idMaskFrame.fillPalette.buffer,\n                    idMaskFrame.strokePalette.buffer,\n                    idMaskFrame.strokeWidths.buffer,\n                    ...coverageTransfers,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame && !regionMaskCoverage) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const preparedPixels = compositedFrame ?? createTransparentCoverageCarrier();\n            const imageData = new ImageData(preparedPixels.data, preparedPixels.width, preparedPixels.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            const idMaskPlane = createIdMaskPlane(message.job.instructions, message.job.maxRasterWidth);\n            const idMaskTransfers = idMaskPlane ? [idMaskPlane.data.buffer] : [];\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    idMaskPlane,\n                    imageBitmap,\n                    key: message.job.key,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [imageBitmap, ...idMaskTransfers, ...coverageTransfers]);\n                return;\n            }\n            workerScope.postMessage({\n                idMaskPlane,\n                imageData,\n                key: message.job.key,\n                regionMaskCoverage,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [imageData.data.buffer, ...idMaskTransfers, ...coverageTransfers]);\n        }\n        catch (error) {\n            workerScope.postMessage({\n                error: error instanceof Error\n                    ? error.message\n                    : \"Unable to prepare mask frame.\",\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Error,\n            });\n        }\n    }\n    /**\n     * A frame that carries only region coverage has nothing to composite, and the\n     * RGBA branch still has to produce an artifact for the coverage to ride on.\n     */\n    function createTransparentCoverageCarrier() {\n        return {\n            data: new Uint8ClampedArray(new ArrayBuffer(4)),\n            height: 1,\n            width: 1,\n        };\n    }\n    function getRegionMaskCoverageTransfers(coverage) {\n        return coverage?.entries.map(({ data }) => data.buffer) ?? [];\n    }\n    function createImageBitmapFromImageData(imageData) {\n        if (typeof OffscreenCanvas === \"undefined\") {\n            return null;\n        }\n        const canvas = new OffscreenCanvas(imageData.width, imageData.height);\n        const context = canvas.getContext(\"2d\");\n        if (!context) {\n            return null;\n        }\n        context.putImageData(imageData, 0, 0);\n        return canvas.transferToImageBitmap();\n    }\n\n})();";
 
 const DEFAULT_WORKER_NAME = "supervision-js-render-preparation";
 let defaultWorkerUrl;
@@ -5443,6 +5343,7 @@ function createPreparedIdMaskFrame(job, regionMaskCoverage) {
         maxStrokeWidth: frame.maxStrokeWidth,
         raster: frame.data,
         regionMaskCoverage,
+        sourceWidth: frame.sourceWidth,
         strokePalette: frame.strokePalette,
         strokeWidths: frame.strokeWidths,
         width: frame.width,
@@ -5552,7 +5453,8 @@ function createPreparedFrameFromWorkerResponse(message) {
             !message.strokePalette ||
             !message.strokeWidths ||
             !message.width ||
-            !message.height) {
+            !message.height ||
+            !message.sourceWidth) {
             throw new Error("Mask preparation worker returned an incomplete ID mask artifact.");
         }
         return {
@@ -5565,6 +5467,7 @@ function createPreparedFrameFromWorkerResponse(message) {
             maxStrokeWidth: message.maxStrokeWidth ?? 0,
             raster: message.raster,
             regionMaskCoverage: message.regionMaskCoverage,
+            sourceWidth: message.sourceWidth,
             strokePalette: message.strokePalette,
             strokeWidths: message.strokeWidths,
             width: message.width,
@@ -5721,9 +5624,9 @@ function resolvePreparedWindowFrameCount(options) {
 }
 function createPreparedRenderWindow(options) {
     const maskFrameOptions = options.renderPreparation?.maskFrame;
-    const maxMaskFrameCacheSize = Math.max(1, options.maxMaskFrameCacheSize ??
+    const maxMaskFrameCacheSize = Math.max(1, Math.floor(options.maxMaskFrameCacheSize ??
         maskFrameOptions?.maxCacheFrameCount ??
-        DEFAULT_MASK_FRAME_CACHE_SIZE);
+        DEFAULT_MASK_FRAME_CACHE_SIZE) || DEFAULT_MASK_FRAME_CACHE_SIZE);
     const prefetchFrameCount = resolvePreparedWindowFrameCount(options);
     const preparedWindowScanIntervalSeconds = Math.max(0, options.preparedWindowScanIntervalSeconds ??
         maskFrameOptions?.scanIntervalSeconds ??
@@ -5753,6 +5656,7 @@ function createPreparedRenderWindow(options) {
     let isPlayheadSettled = true;
     let isDestroyed = false;
     let generation = 0;
+    let preparationProgress = 0;
     const preparedMaskFrames = new Map();
     const pendingMaskFrames = new Map();
     const queuedMaskFrameKeys = [];
@@ -5852,6 +5756,7 @@ function createPreparedRenderWindow(options) {
             });
             if (instructions.length === 0) {
                 emptyMaskFrameKeys.add(key);
+                preparationProgress += 1;
                 pendingMaskFrames.delete(key);
                 inFlightMaskFrames.delete(job);
                 schedulePreparedTargetBatch();
@@ -5881,12 +5786,14 @@ function createPreparedRenderWindow(options) {
                 }
                 if (!maskFrame) {
                     emptyMaskFrameKeys.add(key);
+                    preparationProgress += 1;
                     schedulePreparedTargetBatch();
                     emitDiagnostics();
                     pumpMaskFrameQueue();
                     return;
                 }
                 preparedMaskFrames.set(key, maskFrame);
+                preparationProgress += 1;
                 evictPreparedMaskFrames();
                 options.onMaskFramePrepared?.(maskFrame);
                 schedulePreparedTargetBatch();
@@ -6077,7 +5984,9 @@ function createPreparedRenderWindow(options) {
         if (isDestroyed || terminalPreparationError) {
             return;
         }
-        if (!isPlayheadSettled && !batchOptions.force) {
+        /* A wait held at the gate does not ask again until it is let through, so
+           the hold is what has to keep preparation running. */
+        if (!isPlayheadSettled && !batchOptions.force && getGateHold() === null) {
             return;
         }
         let scheduledFrameCount = 0;
@@ -6098,6 +6007,9 @@ function createPreparedRenderWindow(options) {
     }
     return {
         getFrame,
+        getPreparationProgress() {
+            return preparationProgress;
+        },
         isArtifactPrepared(mediaTime) {
             if (isDestroyed || !maskStyle) {
                 return true;
@@ -6109,8 +6021,14 @@ function createPreparedRenderWindow(options) {
             return (getMaskStatus(getFrameKey(detectionFrame)) !==
                 PreparedRenderFrameMaskStatus.Pending);
         },
-        waitForReady(mediaTime, waitOptions) {
-            if (waitOptions.enabled === false) {
+        needsPlaybackGateWait(mediaTime, waitOptions) {
+            if (isDestroyed || waitOptions.enabled === false) {
+                return false;
+            }
+            return !isReadyForPresentation(mediaTime, getStopBelowSeconds(waitOptions));
+        },
+        waitForReady(mediaTime, waitOptions, signal) {
+            if (waitOptions.enabled === false || signal?.aborted) {
                 return Promise.resolve();
             }
             if (terminalPreparationError) {
@@ -6120,17 +6038,22 @@ function createPreparedRenderWindow(options) {
             if (terminalPreparationError) {
                 return Promise.reject(terminalPreparationError);
             }
-            if (isReadyForPresentation(mediaTime, getMinimumAheadSeconds(waitOptions))) {
+            if (isReadyForPresentation(mediaTime, getStopBelowSeconds(waitOptions))) {
                 return Promise.resolve();
             }
             return new Promise((resolve, reject) => {
                 const activeWait = {
                     mediaTime,
-                    requiredAheadSeconds: getRequiredAheadSeconds(waitOptions),
+                    resumeAtSeconds: getResumeAtSeconds(waitOptions),
                 };
                 const endWait = () => {
                     readinessWaiters.delete(checkReady);
                     activeReadinessWaits.delete(activeWait);
+                    signal?.removeEventListener("abort", abandonWait);
+                };
+                const abandonWait = () => {
+                    endWait();
+                    resolve();
                 };
                 const checkReady = () => {
                     if (terminalPreparationError) {
@@ -6139,7 +6062,7 @@ function createPreparedRenderWindow(options) {
                         return;
                     }
                     if (!isDestroyed &&
-                        !isReadyForPresentation(mediaTime, activeWait.requiredAheadSeconds)) {
+                        !isReadyForPresentation(mediaTime, activeWait.resumeAtSeconds)) {
                         return;
                     }
                     endWait();
@@ -6147,6 +6070,7 @@ function createPreparedRenderWindow(options) {
                 };
                 readinessWaiters.add(checkReady);
                 activeReadinessWaits.add(activeWait);
+                signal?.addEventListener("abort", abandonWait);
                 emitDiagnostics();
             });
         },
@@ -6377,6 +6301,16 @@ function createPreparedRenderWindow(options) {
         }
         return getPreparedAheadDiagnosticsFor(activeMaskFrame);
     }
+    /**
+     * How far prepared work reaches in front of a frame, and how much of that
+     * reach is finished. The walk crosses a frame the scheduler already holds
+     * without counting it and stops at one nobody has asked for: a queued or
+     * in-flight frame is runway that arrives on its own, while a gap no job
+     * covers is runway that never fills. A source still appending detections
+     * drops a fresh uncooked frame into this span on every record it writes.
+     * Whether the frame about to be presented is itself ready is a separate
+     * question, asked separately.
+     */
     function getPreparedAheadDiagnosticsFor(frameRef) {
         const targetFrameIndex = lastPreparedTargetFrames.findIndex((frame) => getFrameKey(frame) === frameRef.key);
         const frames = targetFrameIndex >= 0
@@ -6392,11 +6326,14 @@ function createPreparedRenderWindow(options) {
         let latestPreparedTime = frameRef.mediaTime;
         for (const frame of frames.slice(activeFrameIndex)) {
             const key = getFrameKey(frame);
-            if (!preparedMaskFrames.has(key) && !emptyMaskFrameKeys.has(key)) {
+            if (preparedMaskFrames.has(key) || emptyMaskFrameKeys.has(key)) {
+                frameCount += 1;
+                latestPreparedTime = frame.mediaTime;
+                continue;
+            }
+            if (!pendingMaskFrames.has(key)) {
                 break;
             }
-            frameCount += 1;
-            latestPreparedTime = frame.mediaTime;
         }
         return {
             frameCount,
@@ -6410,6 +6347,21 @@ function createPreparedRenderWindow(options) {
         }
         return lastPreparedWindowFrames.length - activeFrameIndex;
     }
+    /**
+     * The furthest a run of prepared frames starting here can ever reach. The run
+     * is read out of a cache holding a fixed number of frames, and eviction takes
+     * the frame farthest from the playhead, so a lead demanded beyond this span
+     * is one no amount of preparation delivers. Unbounded while the playhead sits
+     * outside the scanned window, the only place the span can be read from.
+     */
+    function getCacheReachableAheadSeconds(frameRef) {
+        const activeFrameIndex = lastPreparedWindowFrames.findIndex((frame) => getFrameKey(frame) === frameRef.key);
+        if (activeFrameIndex < 0) {
+            return Number.POSITIVE_INFINITY;
+        }
+        const lastReachableFrame = lastPreparedWindowFrames[Math.min(lastPreparedWindowFrames.length, activeFrameIndex + maxMaskFrameCacheSize) - 1];
+        return timeline.getFrameDistance(lastReachableFrame.mediaTime, frameRef.mediaTime);
+    }
     function getPreparedTargetAheadSeconds(frameRef) {
         const activeFrameIndex = lastPreparedTargetFrames.findIndex((frame) => getFrameKey(frame) === frameRef.key);
         if (activeFrameIndex < 0) {
@@ -6441,7 +6393,7 @@ function createPreparedRenderWindow(options) {
             mediaTime: detectionFrame.mediaTime,
         };
         const activeStatus = getMaskStatus(frameRef.key);
-        const requiredLeadSeconds = Math.min(Math.max(requiredAheadSeconds, 0), getPreparedTargetAheadSeconds(frameRef));
+        const requiredLeadSeconds = Math.min(Math.max(requiredAheadSeconds, 0), getPreparedTargetAheadSeconds(frameRef), getCacheReachableAheadSeconds(frameRef));
         if (activeStatus === PreparedRenderFrameMaskStatus.Pending) {
             return {
                 reason: RenderPreparationGateHoldReason.ActiveFrameUnprepared,
@@ -6468,7 +6420,7 @@ function createPreparedRenderWindow(options) {
      */
     function getGateHold() {
         for (const wait of activeReadinessWaits) {
-            const hold = getPresentationHold(wait.mediaTime, wait.requiredAheadSeconds);
+            const hold = getPresentationHold(wait.mediaTime, wait.resumeAtSeconds);
             if (hold) {
                 return hold;
             }
@@ -6480,12 +6432,11 @@ function createPreparedRenderWindow(options) {
             waiter();
         }
     }
-    function getRequiredAheadSeconds(waitOptions) {
-        return Math.max(waitOptions.requiredAheadSeconds ?? 0, 0);
+    function getResumeAtSeconds(waitOptions) {
+        return Math.max(waitOptions.resumeAtSeconds, 0);
     }
-    function getMinimumAheadSeconds(waitOptions) {
-        const requiredAheadSeconds = getRequiredAheadSeconds(waitOptions);
-        return Math.min(Math.max(waitOptions.minimumAheadSeconds ?? requiredAheadSeconds, 0), requiredAheadSeconds);
+    function getStopBelowSeconds(waitOptions) {
+        return Math.min(Math.max(waitOptions.stopBelowSeconds, 0), getResumeAtSeconds(waitOptions));
     }
     function createPreparer() {
         return createMaskFramePreparer({
@@ -6815,6 +6766,35 @@ void main(void) {
 }
 `;
 
+/**
+ * Pixi keys its program cache by source, so one program is shared by every
+ * shader built from it. `destroy(true)` takes that program with it, leaving
+ * both the peers still rendering through it and the next shader built from the
+ * same source bound to nothing.
+ */
+function destroyShaderKeepingProgram(shader) {
+    try {
+        shader.destroy();
+    }
+    catch {
+        // Pixi has already invalidated this shader's resource group.
+    }
+}
+/**
+ * Pixi uploads a placeholder while it builds a shader's first bind group, and
+ * WebGPU rejects a canvas that was never given a rendering context.
+ */
+function createShaderPlaceholderCanvas() {
+    if (typeof document === "undefined") {
+        return { height: 1, width: 1 };
+    }
+    const canvas = document.createElement("canvas");
+    canvas.height = 1;
+    canvas.width = 1;
+    canvas.getContext("2d");
+    return canvas;
+}
+
 /**
  * The halo a detection actually paints, or `undefined`. A style may answer an
  * instruction that draws nothing, and both the coverage the halo prepares and
@@ -6860,7 +6840,7 @@ function createPixiMaskHaloRenderer(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas$4(),
+        resource: createShaderPlaceholderCanvas(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -6886,9 +6866,7 @@ function createPixiMaskHaloRenderer(options) {
         destroy() {
             for (const pass of passes) {
                 pass.mesh.destroy();
-                // Never destroy(true): the program cache is keyed by source and shared
-                // by every shader built from it, including other halos still rendering.
-                pass.shader.destroy();
+                destroyShaderKeepingProgram(pass.shader);
             }
             passes.length = 0;
             display.destroy();
@@ -6952,12 +6930,7 @@ function createPixiMaskHaloRenderer(options) {
             pass.shader.resources.uSampler = source.style;
         }
         catch {
-            try {
-                pass.shader.destroy();
-            }
-            catch {
-                // Pixi has already invalidated this shader's resource group.
-            }
+            destroyShaderKeepingProgram(pass.shader);
             pass.shader = createShader(pass.uniforms);
             pass.mesh.shader = pass.shader;
             pass.shader.resources.uTexture = source;
@@ -7007,15 +6980,6 @@ function buildMaskHaloPalette(halos) {
     }
     return palette;
 }
-function createPlaceholderCanvas$4() {
-    const canvas = document.createElement("canvas");
-    canvas.height = 1;
-    canvas.width = 1;
-    // WebGPU rejects a canvas that was never given a rendering context, and Pixi
-    // uploads this placeholder while it builds the shader's first bind group.
-    canvas.getContext("2d");
-    return canvas;
-}
 const maskHaloFragmentShader = `#version 300 es
 precision highp float;
 precision highp int;
@@ -7358,6 +7322,7 @@ function createPixiFocusLayer(options) {
     let cutoutMediaTime = null;
     let cutoutFrameTime = null;
     let drawnOverlayWithoutCutout = null;
+    let isDrawnFocusCleared = false;
     let isHoldingOverlay = false;
     let holdStartedAtMs = null;
     // A frame can fall back to a composited RGBA texture when its colored ID-mask
@@ -7406,7 +7371,7 @@ function createPixiFocusLayer(options) {
                 return;
             }
             if (!context.frame) {
-                holdOverlay(context.mediaTime, context.heldMaskFrameTime ?? null);
+                holdOverlay(context.mediaTime, context.heldMaskFrameTime ?? null, context.isMaskArtifactOwed === true);
                 return;
             }
             const resolvedInstruction = focusStyle.resolve({
@@ -7607,7 +7572,7 @@ function createPixiFocusLayer(options) {
      * Everything dimmed for a moment reads as a pause; the picture flashing to
      * full brightness and back reads as a fault.
      */
-    function holdOverlay(mediaTime, heldMaskFrameTime) {
+    function holdOverlay(mediaTime, heldMaskFrameTime, isMaskArtifactOwed) {
         if (!heldFill) {
             transitionToHidden();
             return;
@@ -7619,6 +7584,12 @@ function createPixiFocusLayer(options) {
         if (isDrawnCutoutStillCurrent(mediaTime, heldMaskFrameTime)) {
             return;
         }
+        if (isMaskArtifactOwed) {
+            // The mask is absent from this frame as well, so a dim with no hole cut
+            // in it darkens the subject itself: a harsher absence than no focus.
+            clearDrawnFocus();
+            return;
+        }
         drawOverlayWithoutCutout(heldFill);
     }
     /**
@@ -7650,11 +7621,13 @@ function createPixiFocusLayer(options) {
         }
     }
     function markCutoutDrawn(mediaTime, frameTime) {
+        isDrawnFocusCleared = false;
         cutoutMediaTime = mediaTime;
         cutoutFrameTime = frameTime;
         drawnOverlayWithoutCutout = null;
     }
     function resetHeldFocus() {
+        isDrawnFocusCleared = false;
         cutoutMediaTime = null;
         cutoutFrameTime = null;
         drawnOverlayWithoutCutout = null;
@@ -7671,11 +7644,23 @@ function createPixiFocusLayer(options) {
         return (idMaskRenderer?.isDrawnFrameIntact() === true ||
             focusGraphics?.visible === true);
     }
+    function clearDrawnFocus() {
+        if (isDrawnFocusCleared) {
+            return;
+        }
+        isDrawnFocusCleared = true;
+        cutoutMediaTime = null;
+        cutoutFrameTime = null;
+        drawnOverlayWithoutCutout = null;
+        idMaskRenderer?.hide();
+        hideVectorFocus();
+    }
     function drawOverlayWithoutCutout(fill) {
         if (drawnOverlayWithoutCutout?.alpha === fill.alpha &&
             drawnOverlayWithoutCutout.color === fill.color) {
             return;
         }
+        isDrawnFocusCleared = false;
         cutoutMediaTime = null;
         cutoutFrameTime = null;
         drawnOverlayWithoutCutout = fill;
@@ -7775,7 +7760,7 @@ function createFocusIdMaskRenderer(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas$3(),
+        resource: createShaderPlaceholderCanvas(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -7807,7 +7792,7 @@ function createFocusIdMaskRenderer(options) {
     return {
         destroy() {
             mesh.destroy();
-            shader.destroy();
+            destroyShaderKeepingProgram(shader);
             geometry.destroy();
             placeholderSource.destroy();
         },
@@ -7907,14 +7892,7 @@ function createFocusIdMaskRenderer(options) {
         });
     }
     function rebuildShader() {
-        try {
-            // Never destroy(true): the program cache is keyed by source and shared
-            // by every shader built from it; a destroyed entry poisons the rebuild.
-            shader.destroy();
-        }
-        catch {
-            // Pixi has already invalidated this shader's resource group.
-        }
+        destroyShaderKeepingProgram(shader);
         shader = createShader();
         mesh.shader = shader;
     }
@@ -7926,15 +7904,6 @@ function writePremultipliedColor(target, fill) {
     target[2] = ((fill.color & 0xff) / 255) * alpha;
     target[3] = alpha;
 }
-function createPlaceholderCanvas$3() {
-    const canvas = document.createElement("canvas");
-    canvas.height = 1;
-    canvas.width = 1;
-    // WebGPU rejects a canvas that was never given a rendering context, and Pixi
-    // uploads this placeholder while it builds the shader's first bind group.
-    canvas.getContext("2d");
-    return canvas;
-}
 const focusIdMaskFragmentShader = `#version 300 es
 precision highp float;
 precision highp int;
@@ -9212,7 +9181,6 @@ function detectionKey(detection, detectionIndex) {
         : `id:${String(detection.id)}`;
 }
 
-const MAX_INTERACTION_STROKE_RADIUS = 12;
 function createPixiInteractionPresentationLayer(options) {
     let interactionStyle = options.interactionStyle === undefined
         ? new BaseInteractionStyle()
@@ -9603,7 +9571,7 @@ function createInteractionMaskRenderer(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas$2(),
+        resource: createShaderPlaceholderCanvas(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -9629,7 +9597,7 @@ function createInteractionMaskRenderer(options) {
     return {
         destroy() {
             mesh.destroy();
-            shader.destroy();
+            destroyShaderKeepingProgram(shader);
             geometry.destroy();
             placeholderSource.destroy();
         },
@@ -9648,14 +9616,16 @@ function createInteractionMaskRenderer(options) {
             strokeWidths.fill(0);
             let maxStrokeWidth = 0;
             for (const { detectionIndex, instruction } of instructions) {
-                const maskId = detectionIndex + 1;
-                if (maskId <= 0 || maskId >= MAX_ID_MASK_PALETTE_ENTRIES) {
+                const maskId = resolveIdMaskPaletteId(detectionIndex);
+                // A raster naming this detection is one the palette accepted, so an id
+                // it cannot hold is an id no texel of this raster carries either.
+                if (maskId === undefined) {
                     continue;
                 }
-                writePaletteEntry(fillPalette, maskId, instruction.color, instruction.alpha);
+                writeIdMaskPaletteEntry(fillPalette, maskId, instruction.color, instruction.alpha);
                 if (instruction.stroke && instruction.stroke.width > 0) {
-                    writePaletteEntry(strokePalette, maskId, instruction.stroke.color, instruction.stroke.alpha);
-                    strokeWidths[maskId] = Math.min(resolveRasterStrokeTexels(instruction.stroke.width, instruction.mask.width, frame.width), MAX_INTERACTION_STROKE_RADIUS);
+                    writeIdMaskPaletteEntry(strokePalette, maskId, instruction.stroke.color, instruction.stroke.alpha);
+                    strokeWidths[maskId] = resolveIdMaskStrokeTexels(instruction.stroke.width, frame.sourceWidth, frame.width);
                     maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidths[maskId] ?? 0);
                 }
             }
@@ -9666,7 +9636,7 @@ function createInteractionMaskRenderer(options) {
                 frame.width,
                 frame.height,
             ]);
-            uniforms.uniforms.uMaxStrokeWidth = Math.min(maxStrokeWidth, MAX_INTERACTION_STROKE_RADIUS);
+            uniforms.uniforms.uMaxStrokeWidth = maxStrokeWidth;
             uniforms.update();
             mesh.visible = true;
         },
@@ -9706,46 +9676,11 @@ function createInteractionMaskRenderer(options) {
         });
     }
     function rebuildShader() {
-        try {
-            // Never destroy(true): the program cache is keyed by source and shared
-            // by every shader built from it; a destroyed entry poisons the rebuild.
-            shader.destroy();
-        }
-        catch {
-            // Pixi has already invalidated this shader's resource group.
-        }
+        destroyShaderKeepingProgram(shader);
         shader = createShader();
         mesh.shader = shader;
     }
 }
-/**
- * A stroke is measured in texels of the raster the shader samples, so a raster
- * cooked below the mask's own resolution measures it in coarser texels. A
- * stroke of a texel or more keeps at least one, the thinnest line the shader
- * can draw; a narrower one keeps its own width, which the shader draws as an
- * inner boundary at any scale.
- */
-function resolveRasterStrokeTexels(strokeWidth, maskWidth, rasterWidth) {
-    const scale = maskWidth > 0 ? rasterWidth / maskWidth : 1;
-    return Math.max(strokeWidth * scale, Math.min(strokeWidth, 1));
-}
-function writePaletteEntry(palette, maskId, color, alpha) {
-    const offset = maskId * 4;
-    const clampedAlpha = Math.max(0, Math.min(alpha, 1));
-    palette[offset] = ((color >> 16) & 0xff) / 255;
-    palette[offset + 1] = ((color >> 8) & 0xff) / 255;
-    palette[offset + 2] = (color & 0xff) / 255;
-    palette[offset + 3] = clampedAlpha;
-}
-function createPlaceholderCanvas$2() {
-    const canvas = document.createElement("canvas");
-    canvas.height = 1;
-    canvas.width = 1;
-    // WebGPU rejects a canvas that was never given a rendering context, and Pixi
-    // uploads this placeholder while it builds the shader's first bind group.
-    canvas.getContext("2d");
-    return canvas;
-}
 const interactionMaskFragmentShader = `#version 300 es
 precision highp float;
 precision highp int;
@@ -9776,7 +9711,7 @@ bool differs(float left, float right) {
 // The winning candidate is the max-(offsetY, offsetX) passing offset, so the
 // scan runs backwards and exits on the first hit.
 float findNeighborStrokeId(float centerId, vec2 texel) {
-  int radius = int(min(uMaxStrokeWidth, float(${MAX_INTERACTION_STROKE_RADIUS})));
+  int radius = int(min(uMaxStrokeWidth, float(${MAX_ID_MASK_STROKE_WIDTH})));
 
   for (int offsetY = radius; offsetY >= -radius; offsetY -= 1) {
     for (int offsetX = radius; offsetX >= -radius; offsetX -= 1) {
@@ -9873,7 +9808,7 @@ fn differs(left: f32, right: f32) -> bool {
 // The winning candidate is the max-(offsetY, offsetX) passing offset, so the
 // scan runs backwards and exits on the first hit.
 fn findNeighborStrokeId(uv: vec2<f32>, centerId: f32, texel: vec2<f32>) -> f32 {
-  let radius = i32(min(maskUniforms.uMaxStrokeWidth, ${MAX_INTERACTION_STROKE_RADIUS}.0));
+  let radius = i32(min(maskUniforms.uMaxStrokeWidth, ${MAX_ID_MASK_STROKE_WIDTH}.0));
 
   for (var offsetY = radius; offsetY >= -radius; offsetY -= 1) {
     for (var offsetX = radius; offsetX >= -radius; offsetX -= 1) {
@@ -9970,7 +9905,7 @@ function createPixiIdMaskShaderRenderer(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas$1(),
+        resource: createShaderPlaceholderCanvas(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -9999,7 +9934,7 @@ function createPixiIdMaskShaderRenderer(options) {
         },
         destroy() {
             mesh.destroy();
-            shader.destroy();
+            destroyShaderKeepingProgram(shader);
             geometry.destroy();
             placeholderSource.destroy();
         },
@@ -10060,27 +9995,11 @@ function createPixiIdMaskShaderRenderer(options) {
         });
     }
     function rebuildShader() {
-        try {
-            // Never destroy(true): the program cache is keyed by source and shared
-            // by every shader built from it; a destroyed entry poisons the rebuild.
-            shader.destroy();
-        }
-        catch {
-            // Pixi has already invalidated this shader's resource group.
-        }
+        destroyShaderKeepingProgram(shader);
         shader = createShader();
         mesh.shader = shader;
     }
 }
-function createPlaceholderCanvas$1() {
-    const canvas = document.createElement("canvas");
-    canvas.height = 1;
-    canvas.width = 1;
-    // WebGPU rejects a canvas that was never given a rendering context, and Pixi
-    // uploads this placeholder while it builds the shader's first bind group.
-    canvas.getContext("2d");
-    return canvas;
-}
 const idMaskFragmentShader = `#version 300 es
 precision highp float;
 precision highp int;
@@ -10278,6 +10197,21 @@ fn mainFragment(
 `;
 
 const TEXTURE_ROW_ALIGNMENT_BYTES = 4;
+/**
+ * Whether the frame on screen can answer for detection ids. Hover, selection
+ * and focus highlighting all cut their shapes out of the id raster, so a frame
+ * that reaches the screen without one draws its whole picture while those three
+ * have nothing to cut from.
+ */
+var PixiMaskLayerIdMaskStatus;
+(function (PixiMaskLayerIdMaskStatus) {
+    /** A mask frame is on screen and carries no id raster. */
+    PixiMaskLayerIdMaskStatus["Absent"] = "absent";
+    /** No mask frame is on screen. */
+    PixiMaskLayerIdMaskStatus["None"] = "none";
+    /** The id raster is on screen. */
+    PixiMaskLayerIdMaskStatus["Present"] = "present";
+})(PixiMaskLayerIdMaskStatus || (PixiMaskLayerIdMaskStatus = {}));
 /**
  * Cook-only style for consumers that read detection ids out of the raster
  * instead of drawing the fill. Ids come from the detection index, so the colour
@@ -10364,15 +10298,14 @@ function createPixiMaskLayer(options) {
                 showMaskFrame(preparedFrame.maskFrame, preparedFrame.detectionFrame.mediaTime, presentedFrameId);
                 return;
             }
-            if (!preparedFrame || !canHoldVisibleMaskOver(preparedFrame)) {
-                hideSprite();
-            }
+            hideSprite();
         },
         getDrawnState() {
             return {
                 drawnFrameTime: visibleMaskMediaTime,
                 drawnFrameKey: visibleMaskFrameKey,
                 drawnFrameId: visibleMaskFrameId,
+                idMaskStatus: resolveIdMaskStatus(),
             };
         },
         prepareFrame(mediaTime) {
@@ -10384,8 +10317,14 @@ function createPixiMaskLayer(options) {
         isArtifactPrepared(mediaTime) {
             return preparedRenderWindow.isArtifactPrepared(mediaTime);
         },
-        waitForRenderPreparation(mediaTime, gateOptions) {
-            return preparedRenderWindow.waitForReady(mediaTime, gateOptions);
+        getPreparationProgress() {
+            return preparedRenderWindow.getPreparationProgress();
+        },
+        needsRenderPreparationWait(mediaTime, gateOptions) {
+            return preparedRenderWindow.needsPlaybackGateWait(mediaTime, gateOptions);
+        },
+        waitForRenderPreparation(mediaTime, gateOptions, signal) {
+            return preparedRenderWindow.waitForReady(mediaTime, gateOptions, signal);
         },
         pickDetectionAtPoint(point, mediaTime) {
             const preparedFrame = preparedRenderWindow.getFrame(mediaTime);
@@ -10488,6 +10427,14 @@ function createPixiMaskLayer(options) {
         }
         showRgbaMaskFrame(maskFrame);
     }
+    function resolveIdMaskStatus() {
+        if (activeIdMaskFrame) {
+            return PixiMaskLayerIdMaskStatus.Present;
+        }
+        return activeRgbaMaskFrame
+            ? PixiMaskLayerIdMaskStatus.Absent
+            : PixiMaskLayerIdMaskStatus.None;
+    }
     function getTexture(maskFrame) {
         const existingTexture = maskTextures.get(maskFrame.key);
         if (existingTexture) {
@@ -10588,26 +10535,6 @@ function createPixiMaskLayer(options) {
         }
         idMaskRenderer?.hide();
     }
-    /**
-     * Whether the raster on screen may stand over a frame whose own cook has not
-     * landed, which it may for exactly the frame beside its own.
-     *
-     * The bound is counted in frames of the timeline and never in seconds. A span
-     * of seconds only means one frame at one frame rate and one playback rate, so
-     * it has to be scaled by the rate to go on meaning it, and that scaling is
-     * what once left a raster twelve frames old on the picture after a fast run.
-     */
-    function canHoldVisibleMaskOver(preparedFrame) {
-        return (preparedFrame.maskStatus === PreparedRenderFrameMaskStatus.Pending &&
-            visibleMaskMediaTime !== null &&
-            isNeighbouringDetectionFrame(visibleMaskMediaTime, preparedFrame.detectionFrame.mediaTime));
-    }
-    function isNeighbouringDetectionFrame(mediaTime, otherMediaTime) {
-        const frames = getBufferedDetectionTimelineFrameSnapshot(options.detectionTimeline);
-        const index = indexOfDetectionFrameAt(frames, mediaTime);
-        const otherIndex = indexOfDetectionFrameAt(frames, otherMediaTime);
-        return (index !== -1 && otherIndex !== -1 && Math.abs(index - otherIndex) === 1);
-    }
     /**
      * Everything the layer hands other layers is a view of the raster on screen,
      * so a draw that puts none up has to drop them all in the same step.
@@ -10893,26 +10820,6 @@ function expandIdsToRgba(ids) {
     }
     return rgba;
 }
-/** Where the frame sits in the timeline's buffer, which is held in media-time
- *  order, or -1 for a time no frame of detections sits on. */
-function indexOfDetectionFrameAt(frames, mediaTime) {
-    let low = 0;
-    let high = frames.length - 1;
-    while (low <= high) {
-        const middle = (low + high) >>> 1;
-        const frameTime = frames[middle].mediaTime;
-        if (frameTime === mediaTime) {
-            return middle;
-        }
-        if (frameTime < mediaTime) {
-            low = middle + 1;
-        }
-        else {
-            high = middle - 1;
-        }
-    }
-    return -1;
-}
 
 function createPixiMaskBrushPreview(options) {
     const { editor } = options.preview;
@@ -11014,6 +10921,7 @@ function createPixiPolygonLayer(options) {
         },
         clearFrame: rasterLayer.clearFrame,
         isArtifactPrepared: rasterLayer.isArtifactPrepared,
+        getPreparationProgress: rasterLayer.getPreparationProgress,
         getVectorFallbackStyle() {
             return vectorFallbackStyle;
         },
@@ -11025,6 +10933,7 @@ function createPixiPolygonLayer(options) {
             styleVersion += 1;
             rasterLayer.setMaskStyle(nextPolygonStyle ? createArtifactStyle() : nextPolygonStyle);
         },
+        needsRenderPreparationWait: rasterLayer.needsRenderPreparationWait,
         setTimelineContext: rasterLayer.setTimelineContext,
         waitForRenderPreparation: rasterLayer.waitForRenderPreparation,
     };
@@ -11168,7 +11077,7 @@ function createPixiRegionCoverageMask(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas(),
+        resource: createShaderPlaceholderCanvas(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -11186,9 +11095,7 @@ function createPixiRegionCoverageMask(options) {
         destroy() {
             effect.destroy();
             display.destroy();
-            // Never destroy(true): the program cache is keyed by source and shared
-            // by every shader built from it; a destroyed entry poisons the rebuild.
-            shader.destroy();
+            destroyShaderKeepingProgram(shader);
             geometry.destroy();
             placeholderSource.destroy();
         },
@@ -11220,14 +11127,7 @@ function createPixiRegionCoverageMask(options) {
             shader.resources.uSampler = source.style;
         }
         catch {
-            try {
-                // Never destroy(true): the program cache is keyed by source and shared
-                // by every shader built from it; a destroyed entry poisons the rebuild.
-                shader.destroy();
-            }
-            catch {
-                // Pixi may already have invalidated this shader resource group.
-            }
+            destroyShaderKeepingProgram(shader);
             shader = createShader();
             display.shader = shader;
             shader.resources.uTexture = source;
@@ -11258,18 +11158,6 @@ function createPixiRegionCoverageMask(options) {
         });
     }
 }
-function createPlaceholderCanvas() {
-    if (typeof document === "undefined") {
-        return { height: 1, width: 1 };
-    }
-    const canvas = document.createElement("canvas");
-    canvas.height = 1;
-    canvas.width = 1;
-    // WebGPU builds this placeholder into the shader's first bind group, and a
-    // canvas that was never given a rendering context has nothing to bind.
-    canvas.getContext("2d");
-    return canvas;
-}
 const regionCoverageMaskVertexShader = `#version 300 es
 precision highp float;
 
@@ -12601,12 +12489,8 @@ const REGION_COVERAGE_ONLY_MASK_STYLE = {
  * media time, so anything past a fade's length lands the overlay at once.
  */
 const STATIC_FOCUS_SETTLE_MS = 10_000;
-/**
- * Presentation fields a render answers to. The style half comes from the
- * renderer registry, so a renderer kind added there joins it on its own.
- */
-const RENDERED_PRESENTATION_FIELDS = [
-    ...resolveAnnotationRendererStyleFields(annotationRendererKinds),
+/** The presentation fields a render answers to that no renderer kind owns. */
+const RENDERED_PRESENTATION_TAIL = [
     "annotationOverlayStyle",
     "backgroundColor",
     "focusStyle",
@@ -12614,6 +12498,14 @@ const RENDERED_PRESENTATION_FIELDS = [
     "renderers",
     "visibility",
 ];
+/**
+ * Presentation fields a render answers to. The style half comes from the
+ * renderer registry, so a renderer kind added there joins it on its own.
+ */
+const RENDERED_PRESENTATION_FIELDS = [
+    ...resolveAnnotationRendererStyleFields(annotationRendererKinds),
+    ...RENDERED_PRESENTATION_TAIL,
+];
 /** Several steps share a bucket: the public timings name fewer than the walk draws. */
 const FRAME_DRAW_TIMING_BUCKETS = {
     drawBox: "boxMs",
@@ -12706,7 +12598,7 @@ async function createPixiMediaScene(options) {
     let isPresenting = false;
     let isDestroyed = false;
     let displayFrameHandle = null;
-    let hasDeferredPresentRender = false;
+    let deferredPresentedFrame = null;
     /**
      * The detection under an editing gesture. The base layers hide it while the
      * annotation overlay draws its live preview, so an edit never shows beside a
@@ -12855,6 +12747,8 @@ async function createPixiMediaScene(options) {
         autoDensity: true,
         autoStart: frameChannel === undefined,
         backgroundColor: options.backgroundColor ?? 0x111111,
+        /* Only the video-engine media path supplies a presented-frame channel, so
+         * which reader opens the clip is also what decides which backend draws. */
         preference: frameChannel ? "webgpu" : RENDER_ENGINE_PREFERENCE,
         resolution: resolvePixiResolution(options.maxDevicePixelRatio),
     });
@@ -13443,10 +13337,20 @@ async function createPixiMediaScene(options) {
                 source: readPresentedSurface(),
             });
         },
-        waitForRenderPreparation(mediaTime, gateOptions) {
+        getRenderPreparationProgress() {
+            return ((maskLayer?.getPreparationProgress() ?? 0) +
+                (polygonLayer?.getPreparationProgress() ?? 0));
+        },
+        needsRenderPreparationWait(mediaTime, gateOptions) {
+            return (maskLayer?.needsRenderPreparationWait(mediaTime, gateOptions) ===
+                true ||
+                polygonLayer?.needsRenderPreparationWait(mediaTime, gateOptions) ===
+                    true);
+        },
+        waitForRenderPreparation(mediaTime, gateOptions, signal) {
             return Promise.all([
-                maskLayer?.waitForRenderPreparation(mediaTime, gateOptions),
-                polygonLayer?.waitForRenderPreparation(mediaTime, gateOptions),
+                maskLayer?.waitForRenderPreparation(mediaTime, gateOptions, signal),
+                polygonLayer?.waitForRenderPreparation(mediaTime, gateOptions, signal),
             ]).then(() => undefined);
         },
         setRenderQuality(maxDevicePixelRatio) {
@@ -13694,6 +13598,8 @@ async function createPixiMediaScene(options) {
                 cancelDisplayFrame(displayFrameHandle);
                 displayFrameHandle = null;
             }
+            deferredPresentedFrame?.frame.close();
+            deferredPresentedFrame = null;
             unsubscribeDetectionTimeline?.();
             disconnectContainerResizeObserver();
             app.cancelResize?.();
@@ -14132,7 +14038,7 @@ async function createPixiMediaScene(options) {
             return;
         }
         if (isFocusArtifactOwed(mediaTime)) {
-            drawFocusWithNothingToCut(mediaTime, maskLayer?.getDrawnState().drawnFrameTime ?? null);
+            drawFocusWithNothingToCut(mediaTime, maskLayer?.getDrawnState().drawnFrameTime ?? null, true);
             return;
         }
         const frame = annotationDetectionTimeline.selectFrame(mediaTime);
@@ -14147,11 +14053,12 @@ async function createPixiMediaScene(options) {
             viewportScale,
         });
     }
-    function drawFocusWithNothingToCut(mediaTime, heldMaskFrameTime) {
+    function drawFocusWithNothingToCut(mediaTime, heldMaskFrameTime, isMaskArtifactOwed = false) {
         focusLayer?.drawFrame({
             frame: undefined,
             heldMaskFrameTime,
             hoveredPick: null,
+            isMaskArtifactOwed,
             mediaTime,
             selectedPick: null,
         });
@@ -14188,8 +14095,7 @@ async function createPixiMediaScene(options) {
         }
         redrawAnnotationsNow();
     }
-    /** Redraws the frame on screen whether or not its readiness moved, for a
-     *  layer that went stale on wall clock rather than on new data. */
+    /** Redraws the frame on screen whether or not its readiness moved. */
     function redrawAnnotationsNow() {
         if (isPresenting || isDestroyed) {
             return;
@@ -14271,10 +14177,21 @@ async function createPixiMediaScene(options) {
         return frameChannel ? currentMediaTime * MILLISECONDS_PER_SECOND : now();
     }
     function handlePresentedFrame(presented) {
-        if (!mediaCompositor) {
+        if (!mediaCompositor || isDestroyed) {
             presented.frame.close();
             return;
         }
+        // The producer may outrun the display refresh. Keep only its newest frame
+        // for the next refresh, and never acknowledge a superseded frame as
+        // presented: neither its pixels nor its annotations reached the canvas.
+        if (displayFrameHandle !== null) {
+            deferredPresentedFrame?.frame.close();
+            deferredPresentedFrame = presented;
+            return;
+        }
+        presentFrameNow(presented);
+    }
+    function presentFrameNow(presented) {
         // Scheduling a cook notifies, and a notification that drew or rendered
         // here would put a second render inside one present.
         isPresenting = true;
@@ -14307,26 +14224,26 @@ async function createPixiMediaScene(options) {
     /**
      * Renders a present at most once per display refresh. Frames arrive as
      * messages from the producer's own thread, so a main thread that falls
-     * behind takes a whole burst in one refresh and submits a scene per frame
-     * that only the last of can reach the screen. Deferring costs no latency:
-     * the skipped render is replaced before the refresh it would have made.
+     * behind keeps only the latest frame for the next refresh. Coalescing before
+     * the atomic present is important: a skipped frame must not upload pixels,
+     * draw annotations, or advance the producer's presented playhead.
      */
     function renderPresent() {
-        if (displayFrameHandle !== null) {
-            hasDeferredPresentRender = true;
-            return;
-        }
         renderScene();
-        displayFrameHandle = requestDisplayFrame(flushDeferredPresentRender);
+        displayFrameHandle = requestDisplayFrame(flushDeferredPresentedFrame);
     }
-    function flushDeferredPresentRender() {
+    function flushDeferredPresentedFrame() {
         displayFrameHandle = null;
-        if (!hasDeferredPresentRender || isDestroyed) {
+        const deferred = deferredPresentedFrame;
+        deferredPresentedFrame = null;
+        if (!deferred) {
             return;
         }
-        hasDeferredPresentRender = false;
-        renderScene();
-        displayFrameHandle = requestDisplayFrame(flushDeferredPresentRender);
+        if (isDestroyed) {
+            deferred.frame.close();
+            return;
+        }
+        presentFrameNow(deferred);
     }
     function renderNow() {
         if (frameChannel)
@@ -14715,14 +14632,14 @@ const DEFAULT_FRAME_RATE = 30;
  * The refresh interval rebuilds a window that already covers the playhead. A gap
  * the window does not reach reloads immediately whatever this says, so this only
  * decides how often covered ground is derived again, and a file's detections do
- * not change under it. Rebuilding a 10 second window every half second cost 15
+ * not change under it. Rebuilding an 8 second window every half second cost 15
  * rebuilds a second at 8x playback, each re-deriving a window overlapping the
  * one it replaced by 95%. A stream keeps the short interval below, because there
  * the source really does gain data.
  */
 const FILE_DETECTION_BUFFER_DEFAULTS = {
     bufferAheadSeconds: 10,
-    bufferBehindSeconds: 0.5,
+    bufferBehindSeconds: 5,
     refreshIntervalSeconds: 2.5,
 };
 const STREAM_DETECTION_BUFFER_DEFAULTS = {
@@ -14738,12 +14655,15 @@ const STREAM_DETECTION_BUFFER_DEFAULTS = {
  */
 const DETECTION_PLAYBACK_GATE_DEFAULTS = {
     enabled: true,
+    maxWaitSeconds: 10,
     requiredAheadSeconds: 2,
 };
 const RENDER_PREPARATION_PLAYBACK_GATE_DEFAULTS = {
     enabled: true,
-    minimumAheadSeconds: 0.25,
+    maxWaitSeconds: DEFAULT_RENDER_PREPARATION_GATE_MAX_WAIT_SECONDS,
     requiredAheadSeconds: 1,
+    resumeMarginWallSeconds: DEFAULT_RENDER_PREPARATION_GATE_RESUME_MARGIN_WALL_SECONDS,
+    stopBelowWallSeconds: DEFAULT_RENDER_PREPARATION_GATE_STOP_BELOW_WALL_SECONDS,
 };
 const MASK_FRAME_DEFAULTS = {
     maxPendingFrameCount: 24,
@@ -14784,6 +14704,11 @@ function resolveMediaSessionDefaults(options) {
         ...(detectionPlaybackGate
             ? {
                 playbackGate: {
+                    // The detection timeline applies this bound even when a caller
+                    // enables only the specific gate and leaves the session switch
+                    // unset. Resolving it here makes the session snapshot describe the
+                    // runtime that will actually open.
+                    maxWaitSeconds: DETECTION_PLAYBACK_GATE_DEFAULTS.maxWaitSeconds,
                     ...(inheritsGateLookahead
                         ? DETECTION_PLAYBACK_GATE_DEFAULTS
                         : undefined),
@@ -15171,13 +15096,24 @@ function createMediaSessionStateSnapshot({ errorMessage, media, normalization, r
     const stoppedForPlayback = renderer?.playbackState === MediaRendererPlaybackState.Buffering;
     const awaitingCoverage = renderer?.detectionBuffer.status === DetectionBufferStatus.AwaitingCoverage;
     const loadingDetections = renderer?.detectionBuffer.status === DetectionBufferStatus.Loading;
+    const awaitingSourceRead = renderer?.source.awaitingRead === true;
     const preparingActiveFrame = (renderPreparation?.artifacts ?? []).some((artifact) => artifact.activeFrame?.status ===
         RenderPreparationArtifactFrameStatus.Pending ||
         Boolean(artifact.gateHold));
+    if (awaitingSourceRead) {
+        activities.push(createActivity({
+            blockingPlayback: true,
+            detail: "The video for this part has not arrived yet",
+            kind: MediaSessionActivityKind.MediaSourceReading,
+            label: "Loading the video",
+            status: MediaSessionActivityStatus.Waiting,
+        }));
+    }
     // A picture stopped for its annotations is not stopped for its own bytes, and
     // a host shown both reads the vaguer one first and tells the viewer the wrong
     // thing. Only the reason nothing more specific claims is reported here.
     if (stoppedForPlayback &&
+        !awaitingSourceRead &&
         !awaitingCoverage &&
         !loadingDetections &&
         !preparingActiveFrame) {
@@ -15219,42 +15155,44 @@ function createMediaSessionStateSnapshot({ errorMessage, media, normalization, r
         const totalCount = artifact.pendingCount + artifact.preparedCount;
         const activeFrameIsPending = artifact.activeFrame?.status ===
             RenderPreparationArtifactFrameStatus.Pending;
-        // A gate banking a lead in front of a finished frame leaves nothing else to
-        // report: the frame is prepared and the queue can be empty, so a loop that
-        // reads only those two says nothing and the wait is described upstream as a
-        // transfer that is not happening.
-        const holdingForLead = artifact.gateHold?.reason ===
-            RenderPreparationGateHoldReason.LeadBelowRequirement;
+        const gateHold = artifact.gateHold ?? null;
+        const leadHold = gateHold?.reason === RenderPreparationGateHoldReason.LeadBelowRequirement
+            ? gateHold
+            : null;
+        // The gate holds the frame about to be presented, which is not the frame on
+        // screen: a hold can name an unprepared frame ahead while the presented one
+        // is prepared and the queue behind it is empty. Reading only those two says
+        // nothing at all, and the picture stops with no activity to explain it.
+        const waitingForFrame = activeFrameIsPending || (gateHold !== null && leadHold === null);
         if (artifact.pendingCount <= 0 &&
             !activeFrameIsPending &&
-            !holdingForLead) {
+            gateHold === null) {
             continue;
         }
-        const holdingPlayback = (activeFrameIsPending || Boolean(artifact.gateHold)) &&
-            stoppedForPlayback;
-        const waiting = activeFrameIsPending || holdingForLead;
+        const holdingPlayback = (activeFrameIsPending || gateHold !== null) && stoppedForPlayback;
+        const waiting = activeFrameIsPending || gateHold !== null;
         activities.push(createActivity({
             artifactKind: artifact.kind,
             blockingPlayback: holdingPlayback,
             blockingPresentation: activeFrameIsPending,
-            detail: activeFrameIsPending
-                ? holdingPlayback
+            detail: leadHold
+                ? `Starting again at ${leadHold.requiredAheadSeconds.toFixed(1)}s of masks ready`
+                : holdingPlayback && waitingForFrame
                     ? "The masks for this frame are not drawn yet"
-                    : `Active frame ${artifact.activeFrame.mediaTime.toFixed(3)}s is waiting for ${artifact.kind}`
-                : holdingForLead
-                    ? "This frame is ready; the video starts once enough is drawn ahead of it"
-                    : null,
+                    : activeFrameIsPending
+                        ? `Active frame ${artifact.activeFrame.mediaTime.toFixed(3)}s is waiting for ${artifact.kind}`
+                        : null,
             kind: MediaSessionActivityKind.RenderPreparing,
-            label: activeFrameIsPending
-                ? holdingPlayback
-                    ? "Waiting for the masks"
-                    : "Preparing active render artifact"
-                : holdingForLead
-                    ? "Drawing ahead of the video"
+            label: leadHold
+                ? "Catching the masks up"
+                : waitingForFrame
+                    ? holdingPlayback
+                        ? "Waiting for the masks"
+                        : "Preparing active render artifact"
                     : "Preparing render artifacts",
             pendingCount: artifact.pendingCount,
             preparedCount: artifact.preparedCount,
-            progress: holdingForLead
+            progress: leadHold
                 ? leadProgress(artifact)
                 : totalCount > 0
                     ? artifact.preparedCount / totalCount
@@ -15264,6 +15202,14 @@ function createMediaSessionStateSnapshot({ errorMessage, media, normalization, r
                 : MediaSessionActivityStatus.Running,
         }));
     }
+    if (renderer?.renderPreparationGateAbandoned === true) {
+        activities.push(createActivity({
+            detail: "The video is playing without them",
+            kind: MediaSessionActivityKind.RenderPreparationAbandoned,
+            label: "Masks could not keep up",
+            status: MediaSessionActivityStatus.Waiting,
+        }));
+    }
     if (renderer?.playbackState === MediaRendererPlaybackState.Error) {
         activities.push(createActivity({
             blockingPlayback: true,
@@ -15786,5 +15732,5 @@ function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
 
-export { ConversionFrameEffect, DEFAULT_NORMALIZATION_FRAME_RATE, DetectionPostProcessingMode, DetectionTimelineOrigin, MediaConditionCode, MediaConditionResponse, MediaConditionScope, MediaIndexPlacement, MediaNormalizationAudioCodec, MediaNormalizationContainer, MediaNormalizationFit, MediaNormalizationVideoCodec, MediaPreparationError, MediaProbeIssueCode, MediaProbeStatus, MediaSessionMediaBranch, MediaSourceError, RenderPreparationArtifactFrameStatus, RenderPreparationArtifactKind, RenderPreparationExecutionMode, RenderPreparationMode, RenderPreparationWorkerStatus, createBrowserColdDetectionFrameStore, createChunkedDetectionFrameSource, createDefaultDetectionPostProcessingWorkerFactory, createDetectionPostProcessingPipeline, createImageUrlMediaSource, createMediaRenderer, createMediaSession, createMediaStreamRendererSource, createStaticImageMediaSource, createVideoEngineMediaRendererSource, describeConversionFrameEffect, evaluateMediaConditions, getMediaErrorKind, isMediaSourceError, normalizeMedia, normalizeMediaProgressively, openVideoEngineMediaSource, prepareMedia, prepareMediaProgressively, probeMedia, probeMediaConditions, readIndexPlacement, resolveMediaSessionDefaults, summarizeTiming, toMediaSourceError };
+export { DEFAULT_NORMALIZATION_FRAME_RATE, DetectionPostProcessingMode, DetectionTimelineOrigin, MediaNormalizationAudioCodec, MediaNormalizationContainer, MediaNormalizationFit, MediaNormalizationVideoCodec, MediaPreparationError, MediaProbeIssueCode, MediaProbeStatus, MediaSessionMediaBranch, MediaSourceError, RenderPreparationArtifactFrameStatus, RenderPreparationArtifactKind, RenderPreparationExecutionMode, RenderPreparationMode, RenderPreparationWorkerStatus, createBrowserColdDetectionFrameStore, createChunkedDetectionFrameSource, createDefaultDetectionPostProcessingWorkerFactory, createDetectionPostProcessingPipeline, createImageUrlMediaSource, createMediaRenderer, createMediaSession, createMediaStreamRendererSource, createStaticImageMediaSource, normalizeMedia, normalizeMediaProgressively, prepareMedia, prepareMediaProgressively, probeMedia, resolveMediaSessionDefaults, toMediaSourceError };
 //# sourceMappingURL=index.js.map