supervision 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,5 +1,5 @@
-import { copySortedDetectionFrames, detectionFrameOverlapsRange, projectDetectionFrameForTracking, createSortTracker, createOCSortTracker, createCBIoUTracker, createByteTrackTracker, includeDefined, MediaSourceStatus, MediaRendererPlaybackState, MediaRendererFit, createDefaultAnnotationPresentation, createArrayDetectionFrameSource, createBufferedDetectionTimeline, resolveAnnotationRendererPresentation, createIdleDetectionBufferState, MediaInteractionMode, StrokeAlignment, BaseBoxStyle, centerRectToTopLeftRect, BoxShape, BaseFocusStyle, decodeCompressedRleMask, extractMaskRectRuns, AnnotationGestureStateKind, AnnotationHandleKind, getDetectionRect, DetectionPickTarget, createDetectionPickKey, rebaseDetectionPickToFrame, pickDetectionAtPoint, followDetectionPickAcrossFrames, haveSameDetectionPickIdentities, pickAnnotationHandle, getAnnotationHandles, createIdMaskFrame, encodeBinaryMask, rasterizePolygonToMask, LabelPlacement, BasePolygonStyle, BasePolylineStyle, BaseKeypointStyle, KeypointMarkerShape, MarkerSizeSpace, MarkerShape, ShapeInstructionKind, sampleEllipseArc, resolveEllipseSegmentCount, resolveMarkerGeometry, BaseInteractionStyle, DetectionInteractionState, MAX_ID_MASK_PALETTE_ENTRIES, DetectionBufferStatus, canReuseMaskStyleArtifacts, getBufferedDetectionTimelineFrameSnapshot, MAX_ID_MASK_STROKE_WIDTH, resolveMaskStyleOpacity, pickDetectionByMaskId, BoxStrokeAlignment, resolveStyleValue, resolveAnnotationStyleState, lightenColor, createViewportController, MediaSessionMode, DetectionFrameRetentionMode, createMemoryColdDetectionFrameStore, createWritableDetectionFrameSource, createCompositeDetectionFrameSource, MediaSessionActivityStatus, MediaSessionActivityKind, MediaSessionStatus, createSourceAwarePresentation } 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, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, RegionRendererComposeMode, RegionRendererRegionKind, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, TrackingGeometry, annotationRendererKinds, annotationRenderers, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createMemoryColdDetectionFrameStore, createOCSortTracker, createSortTracker, createWritableDetectionFrameSource, detectionPostProcessors, normalizeDetectionClassName, pickDetectionAtPoint, projectDetectionFrameForTracking, resolveDetectionClassColorStyle } from 'supervision-js-core';
+import { copySortedDetectionFrames, detectionFrameOverlapsRange, projectDetectionFrameForTracking, createSortTracker, createOCSortTracker, createCBIoUTracker, createByteTrackTracker, MediaErrorKind, includeDefined, MediaSourceStatus, MediaRendererPlaybackState, MediaRendererFit, createDefaultAnnotationPresentation, createProjectedDetectionFrameSource, createArrayDetectionFrameSource, createBufferedDetectionTimeline, resolveAnnotationRendererPresentation, createIdleDetectionBufferState, MediaInteractionMode, StrokeAlignment, BaseBoxStyle, centerRectToTopLeftRect, BoxShape, BaseFocusStyle, decodeCompressedRleMask, extractMaskRectRuns, AnnotationGestureStateKind, AnnotationHandleKind, getDetectionRect, DetectionPickTarget, createDetectionPickKey, rebaseDetectionPickToFrame, pickDetectionAtPoint, followDetectionPickAcrossFrames, haveSameDetectionPickIdentities, pickAnnotationHandle, getAnnotationHandles, createIdMaskFrame, encodeBinaryMask, rasterizePolygonToMask, LabelPlacement, BasePolygonStyle, BasePolylineStyle, BaseKeypointStyle, KeypointMarkerShape, MarkerSizeSpace, MarkerShape, ShapeInstructionKind, sampleEllipseArc, resolveEllipseSegmentCount, resolveMarkerGeometry, BaseInteractionStyle, DetectionInteractionState, MAX_ID_MASK_PALETTE_ENTRIES, DetectionBufferStatus, canReuseMaskStyleArtifacts, getBufferedDetectionTimelineFrameSnapshot, MAX_ID_MASK_STROKE_WIDTH, resolveMaskStyleOpacity, pickDetectionByMaskId, BoxStrokeAlignment, resolveStyleValue, resolveAnnotationStyleState, lightenColor, 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, RegionRendererComposeMode, RegionRendererRegionKind, 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';
 
 const DEFAULT_DATABASE_NAME = "supervision-js-detection-frames";
 const DEFAULT_CHUNK_DURATION_SECONDS = 1;
@@ -458,7 +458,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        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        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex`, `frameRate`,\n         * and optional `frameIndexOriginTime`. This is useful when inference was run\n         * on normalized frames and playback should snap detections to that grid.\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     * 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    /**\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        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        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        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex`, `frameRate`,\n         * and optional `frameIndexOriginTime`. This is useful when inference was run\n         * on normalized frames and playback should snap detections to that grid.\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    /**\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        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 DEFAULT_WORKER_NAME$1 = "supervision-detection-post-processing";
 let defaultWorkerUrl$1;
@@ -946,23 +946,162 @@ var MediaProbeIssueCode;
     MediaProbeIssueCode["TargetVideoCannotEncode"] = "targetVideoCannotEncode";
 })(MediaProbeIssueCode || (MediaProbeIssueCode = {}));
 
+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;
+    return new MediaSourceError(classifyMediaErrorMessage(message), 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 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.
+ *
+ * Media trimmed through an edit list — B-frame pre-roll is the common case —
+ * carries a few decodable samples ahead of presentation time zero, and the
+ * container reports a negative first timestamp for them. Those samples are not
+ * meant to be presented, but a renderer that starts its clock at the reported
+ * first timestamp would show negative session time and would look for
+ * detections outside `[0, duration]`, where no producer writes them.
+ *
+ * This reports the presentation start as the first timestamp, drops samples
+ * that end before zero, and presents the sample straddling zero at zero.
+ * Sources that already start at or after zero are returned unchanged.
+ */
+function normalizeMediaSourcePresentationTimeline(source) {
+    if (source.metadata.firstTimestamp >= 0) {
+        return source;
+    }
+    return {
+        ...source,
+        metadata: { ...source.metadata, firstTimestamp: 0 },
+        sampleSink: createPresentationTimelineSampleSink(source.sampleSink),
+    };
+}
+function createPresentationTimelineSampleSink(sink) {
+    return {
+        async getSample(timestamp, options) {
+            const sample = await sink.getSample(Math.max(0, timestamp), options);
+            if (!sample) {
+                return null;
+            }
+            if (sample.timestamp >= 0) {
+                return sample;
+            }
+            if (isVisibleSample(sample)) {
+                return clampSampleToZero(sample);
+            }
+            // Random access can land on pre-roll that ends at or before zero. That
+            // sample is never presented, so fall forward to the first visible one
+            // instead of showing a zero-duration frame at time zero.
+            sample.close();
+            return getFirstVisibleSample(sink, options);
+        },
+        async *samples(startTimestamp, endTimestamp, options) {
+            for await (const sample of sink.samples(Math.max(0, startTimestamp ?? 0), endTimestamp, options)) {
+                if (sample.timestamp >= 0) {
+                    yield sample;
+                    continue;
+                }
+                if (isVisibleSample(sample)) {
+                    yield clampSampleToZero(sample);
+                    continue;
+                }
+                sample.close();
+            }
+        },
+    };
+}
+/**
+ * Pre-roll that ends at or before presentation time zero is decodable but not
+ * presentable, so it is never a valid answer for a seek.
+ */
+function isVisibleSample(sample) {
+    return sample.timestamp + sample.duration > 0;
+}
+async function getFirstVisibleSample(sink, options) {
+    for await (const sample of sink.samples(0, undefined, options)) {
+        if (sample.timestamp >= 0) {
+            return sample;
+        }
+        if (isVisibleSample(sample)) {
+            return clampSampleToZero(sample);
+        }
+        sample.close();
+    }
+    return null;
+}
+function clampSampleToZero(sample) {
+    return {
+        close: () => sample.close(),
+        draw: (context, dx, dy, dWidth, dHeight) => sample.draw(context, dx, dy, dWidth, dHeight),
+        duration: Math.max(0, sample.duration + sample.timestamp),
+        timestamp: 0,
+    };
+}
+
 const FRAME_RATE_SAMPLE_PACKET_COUNT = 120;
 async function openMediabunnyMediaSource(sourceInput) {
-    const { Input, MATROSKA, MP4, QTFF, UrlSource, VideoSampleSink, WEBM } = await import('mediabunny');
-    const source = isUrlSourceInput(sourceInput)
-        ? new UrlSource(sourceInput)
-        : sourceInput.source;
-    const formats = isUrlSourceInput(sourceInput)
-        ? [MP4, QTFF, WEBM, MATROSKA]
-        : [...(sourceInput.formats ?? [MP4, QTFF, WEBM, MATROSKA])];
-    const input = new Input({
-        formats,
-        source,
-    });
+    // Loading the decoder and constructing its input can fail on their own, for
+    // example when the module chunk cannot be fetched. Classify those the same
+    // way as a read failure so nothing leaves this source untyped.
+    const { VideoSampleSink, input } = await createMediabunnyInput(sourceInput);
     try {
         const canRead = await input.canRead();
         if (!canRead) {
-            throw new Error("Mediabunny cannot read this media source.");
+            throw new MediaSourceError(MediaErrorKind.Unreadable, "Mediabunny cannot read this media source.");
         }
         const [format, mimeType, metadataDuration, tracks, videoTracks, audioTracks,] = await Promise.all([
             input.getFormat(),
@@ -974,7 +1113,7 @@ async function openMediabunnyMediaSource(sourceInput) {
         ]);
         const primaryVideoTrack = await input.getPrimaryVideoTrack();
         if (!primaryVideoTrack) {
-            throw new Error("No video track found in media source.");
+            throw new MediaSourceError(MediaErrorKind.NoVideoTrack, "No video track found in media source.");
         }
         const packetStatsPromise = typeof primaryVideoTrack.computePacketStats === "function"
             ? primaryVideoTrack
@@ -1000,7 +1139,7 @@ async function openMediabunnyMediaSource(sourceInput) {
         const estimatedFrameCount = duration !== null && estimatedFrameRate !== null
             ? Math.max(1, Math.round(duration * estimatedFrameRate))
             : null;
-        return {
+        return normalizeMediaSourcePresentationTimeline({
             input,
             metadata: {
                 audioTrackCount: audioTracks.length,
@@ -1018,11 +1157,29 @@ async function openMediabunnyMediaSource(sourceInput) {
                 videoTrackCount: videoTracks.length,
             },
             sampleSink: new VideoSampleSink(primaryVideoTrack),
-        };
+        });
     }
     catch (error) {
         input.dispose();
-        throw error;
+        throw toMediaSourceError(error, "Unable to open this media source.");
+    }
+}
+async function createMediabunnyInput(sourceInput) {
+    try {
+        const { Input, MATROSKA, MP4, QTFF, UrlSource, VideoSampleSink, WEBM } = await import('mediabunny');
+        const source = isUrlSourceInput(sourceInput)
+            ? new UrlSource(sourceInput)
+            : sourceInput.source;
+        const formats = isUrlSourceInput(sourceInput)
+            ? [MP4, QTFF, WEBM, MATROSKA]
+            : [...(sourceInput.formats ?? [MP4, QTFF, WEBM, MATROSKA])];
+        return {
+            VideoSampleSink,
+            input: new Input({ formats, source }),
+        };
+    }
+    catch (error) {
+        throw toMediaSourceError(error, "Unable to open this media source.");
     }
 }
 function isUrlSourceInput(input) {
@@ -1523,12 +1680,19 @@ function formatPreparationErrorMessage(probe) {
 function createStaticImageMediaSource(source) {
     return {
         async open() {
-            if (typeof HTMLImageElement !== "undefined" &&
-                source instanceof HTMLImageElement) {
-                await waitForImage(source);
+            try {
+                if (typeof HTMLImageElement !== "undefined" &&
+                    source instanceof HTMLImageElement) {
+                    await waitForImage(source);
+                }
+                const dimensions = getDimensions(source);
+                return createSingleFrameSource(source, dimensions.width, dimensions.height);
+            }
+            catch (error) {
+                // Decode and dimension failures leave through a public source, so they
+                // carry a stable kind and preserve the original cause.
+                throw toMediaSourceError(error, "Unable to open image media source.");
             }
-            const dimensions = getDimensions(source);
-            return createSingleFrameSource(source, dimensions.width, dimensions.height);
         },
     };
 }
@@ -1593,7 +1757,7 @@ function getDimensions(source) {
         source instanceof HTMLImageElement) {
         return { width: source.naturalWidth, height: source.naturalHeight };
     }
-    throw new Error("Static image source dimensions must be greater than zero.");
+    throw new MediaSourceError(MediaErrorKind.Unreadable, "Static image source dimensions must be greater than zero.");
 }
 async function waitForImage(image) {
     if (image.complete && image.naturalWidth > 0)
@@ -1604,7 +1768,7 @@ async function waitForImage(image) {
     }
     await new Promise((resolve, reject) => {
         image.addEventListener("load", () => resolve(), { once: true });
-        image.addEventListener("error", () => reject(new Error("Unable to load image.")), { once: true });
+        image.addEventListener("error", () => reject(new MediaSourceError(MediaErrorKind.Network, "Unable to load image.")), { once: true });
     });
 }
 
@@ -1628,13 +1792,13 @@ function createMediaStreamRendererSource(stream, options = {}) {
 async function openMediaStreamMediaSource(stream, options) {
     if (typeof document === "undefined" ||
         typeof createImageBitmap === "undefined") {
-        throw new Error("MediaStream rendering requires browser media APIs.");
+        throw new MediaSourceError(MediaErrorKind.EnvironmentUnsupported, "MediaStream rendering requires browser media APIs.");
     }
     const maxBufferedFrames = resolveMaxBufferedFrames(options.maxBufferedFrames);
     const videoTracks = stream.getVideoTracks();
     const audioTracks = stream.getAudioTracks();
     if (videoTracks.length === 0) {
-        throw new Error("MediaStream does not contain a video track.");
+        throw new MediaSourceError(MediaErrorKind.NoVideoTrack, "MediaStream does not contain a video track.");
     }
     const video = document.createElement("video");
     video.autoplay = true;
@@ -1719,20 +1883,33 @@ async function openMediaStreamMediaSource(stream, options) {
         }
         notifyWaiters();
     };
-    const capturePresentedFrame = async (mediaTime) => {
+    const toSessionTimestamp = (mediaTime) => {
+        const mediaTimestamp = Number.isFinite(mediaTime)
+            ? mediaTime
+            : video.currentTime;
+        firstMediaTimestamp ??= mediaTimestamp;
+        return options.timestampOrigin === "first-frame"
+            ? Math.max(0, mediaTimestamp - firstMediaTimestamp)
+            : mediaTimestamp;
+    };
+    const reportPresentedFrame = (frame) => {
+        if (!options.onPresentedFrame)
+            return;
+        try {
+            options.onPresentedFrame(frame);
+        }
+        catch {
+            // Presented-frame reporting is host telemetry; never let it stop
+            // decoding the live stream.
+        }
+    };
+    const capturePresentedFrame = async (timestamp) => {
         callbackHandle = undefined;
         callbackKind = undefined;
         if (disposed || ended || terminalError !== undefined)
             return;
         try {
             const image = await createImageBitmap(video);
-            const mediaTimestamp = Number.isFinite(mediaTime)
-                ? mediaTime
-                : video.currentTime;
-            firstMediaTimestamp ??= mediaTimestamp;
-            const timestamp = options.timestampOrigin === "first-frame"
-                ? Math.max(0, mediaTimestamp - firstMediaTimestamp)
-                : mediaTimestamp;
             enqueueFrame({
                 duration: fallbackFrameDuration,
                 image,
@@ -1755,13 +1932,17 @@ async function openMediaStreamMediaSource(stream, options) {
         if (typeof video.requestVideoFrameCallback === "function") {
             callbackKind = "video";
             callbackHandle = video.requestVideoFrameCallback((_now, metadata) => {
-                void capturePresentedFrame(metadata.mediaTime);
+                const timestamp = toSessionTimestamp(metadata.mediaTime);
+                reportPresentedFrame(toPresentedFrame(timestamp, metadata));
+                void capturePresentedFrame(timestamp);
             });
             return;
         }
         callbackKind = "animation";
         callbackHandle = window.requestAnimationFrame(() => {
-            void capturePresentedFrame(video.currentTime);
+            const timestamp = toSessionTimestamp(video.currentTime);
+            reportPresentedFrame({ mediaTime: timestamp });
+            void capturePresentedFrame(timestamp);
         });
     }
     const waitForChange = () => {
@@ -1849,7 +2030,7 @@ async function openMediaStreamMediaSource(stream, options) {
             throw terminalError;
         const firstFrame = bufferedFrames[0];
         if (!firstFrame)
-            throw new Error("MediaStream ended before producing a video frame.");
+            throw new MediaSourceError(MediaErrorKind.Unreadable, "MediaStream ended before producing a video frame.");
         return {
             input: { dispose },
             metadata: {
@@ -1871,9 +2052,28 @@ async function openMediaStreamMediaSource(stream, options) {
     catch (error) {
         dispose();
         rejectWaiters(error);
-        throw error;
+        // Playback and capture failures reach the public source boundary here.
+        // Classify them so consumers branch on a kind instead of vendor text.
+        throw toMediaSourceError(error, "Unable to start MediaStream playback.");
     }
 }
+function toPresentedFrame(mediaTime, metadata) {
+    return {
+        mediaTime,
+        ...includeDefined({
+            expectedDisplayTime: finiteOrUndefined(metadata.expectedDisplayTime),
+            height: finiteOrUndefined(metadata.height),
+            presentationTime: finiteOrUndefined(metadata.presentationTime),
+            rtpTimestamp: finiteOrUndefined(metadata.rtpTimestamp),
+            width: finiteOrUndefined(metadata.width),
+        }),
+    };
+}
+function finiteOrUndefined(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
 function createDecodedSample(frame) {
     let closed = false;
     return {
@@ -2436,6 +2636,7 @@ function createLoadingMediaSourceState() {
         estimatedFrameCount: null,
         estimatedFrameRate: null,
         firstTimestamp: null,
+        errorKind: null,
         errorMessage: null,
         formatMimeType: null,
         formatName: null,
@@ -2455,6 +2656,7 @@ function createReadyMediaSourceState(metadata) {
         estimatedFrameCount: metadata.estimatedFrameCount ?? null,
         estimatedFrameRate: metadata.estimatedFrameRate ?? null,
         firstTimestamp: metadata.firstTimestamp,
+        errorKind: null,
         errorMessage: null,
         formatMimeType: metadata.formatMimeType,
         formatName: metadata.formatName,
@@ -2646,8 +2848,10 @@ function estimateFrameIndex(mediaTime, firstTimestamp, estimatedFrameRate, estim
         : Math.min(index, Math.max(0, estimatedFrameCount - 1));
 }
 function createMediaRenderErrorSourcePatch(error) {
+    const mediaError = toMediaSourceError(error, "Media decode failed.");
     return {
-        errorMessage: error instanceof Error ? error.message : "Media decode failed.",
+        errorKind: mediaError.kind,
+        errorMessage: mediaError.message,
         status: MediaSourceStatus.Error,
     };
 }
@@ -2750,7 +2954,10 @@ async function createMediaRendererCore(options, providers) {
             if (!playbackController) {
                 throw new Error("Media renderer is not ready.");
             }
-            if (runtimeState.isPlaybackActive()) {
+            // Buffering is a stalled form of playing, not a settled one: the
+            // controller may already have been stopped by a seek taken while the
+            // gate was open. Only a run that is genuinely playing can no-op here.
+            if (runtimeState.isPlaying()) {
                 return;
             }
             runtimeState.setPlaying();
@@ -2773,7 +2980,9 @@ async function createMediaRendererCore(options, providers) {
             if (!playbackController || !sampleSink) {
                 throw new Error("Media renderer is not ready.");
             }
-            const wasPlaying = runtimeState.isPlaying();
+            // 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;
             const targetTime = clampSeekTime({
                 duration: runtimeState.duration(),
@@ -2799,6 +3008,11 @@ async function createMediaRendererCore(options, providers) {
                     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 ||
@@ -2948,8 +3162,17 @@ async function createMediaRendererCore(options, providers) {
         }
         const { metadata } = mediaSource;
         firstTimestamp = metadata.firstTimestamp;
-        const detectionSource = options.detectionSource ??
-            createArrayDetectionFrameSource(options.detectionFrames);
+        // One central projection step for every detection input this renderer can
+        // receive: static frames, a caller-owned source, or a composite source.
+        // Media dimensions are known here, so a producer can declare its own
+        // coordinate space and have vector geometry projected exactly once.
+        const detectionSource = createProjectedDetectionFrameSource(options.detectionSource ??
+            createArrayDetectionFrameSource(options.detectionFrames), () => metadata.primaryVideoWidth > 0 && metadata.primaryVideoHeight > 0
+            ? {
+                height: metadata.primaryVideoHeight,
+                width: metadata.primaryVideoWidth,
+            }
+            : null);
         detectionTimeline = createBufferedDetectionTimeline({
             source: options.detectionTimelineOrigin ===
                 DetectionTimelineOrigin.MediaStart && metadata.firstTimestamp !== 0
@@ -5901,7 +6124,7 @@ void main(void) {
 }
 `;
 
-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        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        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex`, `frameRate`,\n         * and optional `frameIndexOriginTime`. This is useful when inference was run\n         * on normalized frames and playback should snap detections to that grid.\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 assertMaskDimensions(data, 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        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.ceil(intersections[index]));\n                const right = Math.min(dimensions.width - 1, Math.floor(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    const MAX_ID_MASK_PALETTE_ENTRIES = 64;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...instructions.map(({ mask }) => mask.width));\n        const height = Math.max(...instructions.map(({ mask }) => mask.height));\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(Math.max(0, instruction.stroke.width), 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            const decodedMask = decodeCompressedRleMask(instruction.mask);\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                        data[y * width + x] = detectionMaskId;\n                    }\n                }\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\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     * 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    /**\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        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    const PNG_SIGNATURE = new Uint8Array([\n        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,\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 createMaskIdFrame(instructions) {\n        return createIdMaskFrame(materializeMaskInstructions(instructions));\n    }\n    async function createPngIdMaskFrame(instructions) {\n        const frame = createMaskIdFrame(instructions);\n        if (!frame) {\n            return undefined;\n        }\n        return {\n            ...frame,\n            png: await encodeGrayscalePng({\n                height: frame.height,\n                pixels: frame.data,\n                width: frame.width,\n            }),\n        };\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.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    async function encodeGrayscalePng(options) {\n        if (typeof CompressionStream === \"undefined\") {\n            throw new Error(\"CompressionStream is required to encode PNG ID masks.\");\n        }\n        const rawScanlines = createFilterlessPngScanlines(options);\n        const ihdr = new Uint8Array(13);\n        const ihdrView = new DataView(ihdr.buffer);\n        ihdrView.setUint32(0, options.width);\n        ihdrView.setUint32(4, options.height);\n        ihdr[8] = 8;\n        ihdr[9] = 0;\n        ihdr[10] = 0;\n        ihdr[11] = 0;\n        ihdr[12] = 0;\n        const compressed = new Uint8Array(await new Response(new Blob([rawScanlines])\n            .stream()\n            .pipeThrough(new CompressionStream(\"deflate\"))).arrayBuffer());\n        return concatUint8Arrays([\n            PNG_SIGNATURE,\n            createPngChunk(\"IHDR\", ihdr),\n            createPngChunk(\"IDAT\", compressed),\n            createPngChunk(\"IEND\", new Uint8Array(0)),\n        ]);\n    }\n    function createFilterlessPngScanlines(options) {\n        const rowStride = options.width + 1;\n        const scanlines = new Uint8Array(rowStride * options.height);\n        for (let y = 0; y < options.height; y += 1) {\n            const sourceOffset = y * options.width;\n            const targetOffset = y * rowStride;\n            scanlines[targetOffset] = 0;\n            scanlines.set(options.pixels.subarray(sourceOffset, sourceOffset + options.width), targetOffset + 1);\n        }\n        return scanlines;\n    }\n    function createPngChunk(type, data) {\n        const typeBytes = new TextEncoder().encode(type);\n        const chunk = new Uint8Array(12 + data.length);\n        const view = new DataView(chunk.buffer);\n        view.setUint32(0, data.length);\n        chunk.set(typeBytes, 4);\n        chunk.set(data, 8);\n        view.setUint32(8 + data.length, crc32(concatUint8Arrays([typeBytes, data])));\n        return chunk;\n    }\n    const crc32Table = createCrc32Table();\n    function createCrc32Table() {\n        const table = new Uint32Array(256);\n        for (let index = 0; index < table.length; index += 1) {\n            let value = index;\n            for (let bit = 0; bit < 8; bit += 1) {\n                value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;\n            }\n            table[index] = value >>> 0;\n        }\n        return table;\n    }\n    function crc32(bytes) {\n        let crc = 0xffffffff;\n        for (const byte of bytes) {\n            crc = crc32Table[(crc ^ byte) & 0xff] ^ (crc >>> 8);\n        }\n        return (crc ^ 0xffffffff) >>> 0;\n    }\n    function concatUint8Arrays(chunks) {\n        const totalLength = chunks.reduce((total, chunk) => total + chunk.length, 0);\n        const result = new Uint8Array(totalLength);\n        let offset = 0;\n        for (const chunk of chunks) {\n            result.set(chunk, offset);\n            offset += chunk.length;\n        }\n        return result;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"PngIdMask\"] = \"pngIdMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\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        void prepareMaskFrame(message);\n    });\n    async function prepareMaskFrame(message) {\n        try {\n            const pngIdMaskFrame = await createPngIdMaskWorkerResponse(message);\n            if (pngIdMaskFrame) {\n                workerScope.postMessage(pngIdMaskFrame, [\n                    pngIdMaskFrame.imageBitmap,\n                    pngIdMaskFrame.png.buffer,\n                    pngIdMaskFrame.fillPalette.buffer,\n                    pngIdMaskFrame.strokePalette.buffer,\n                    pngIdMaskFrame.strokeWidths.buffer,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const imageData = new ImageData(compositedFrame.data, compositedFrame.width, compositedFrame.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            const idMaskData = createMaskIdFrame(message.job.instructions)?.data;\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    imageBitmap,\n                    idMaskData,\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [...(idMaskData ? [idMaskData.buffer] : []), imageBitmap]);\n                return;\n            }\n            workerScope.postMessage({\n                idMaskData,\n                imageData,\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [...(idMaskData ? [idMaskData.buffer] : []), imageData.data.buffer]);\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    async function createPngIdMaskWorkerResponse(message) {\n        if (typeof Blob === \"undefined\" ||\n            typeof createImageBitmap === \"undefined\" ||\n            typeof CompressionStream === \"undefined\") {\n            return undefined;\n        }\n        let frame;\n        try {\n            frame = await createPngIdMaskFrame(message.job.instructions);\n        }\n        catch {\n            return undefined;\n        }\n        if (!frame) {\n            return undefined;\n        }\n        let imageBitmap;\n        try {\n            imageBitmap = await createImageBitmap(new Blob([frame.png], { type: \"image/png\" }));\n        }\n        catch {\n            return undefined;\n        }\n        return {\n            artifactKind: PreparedMaskFrameKind.PngIdMask,\n            fillPalette: frame.fillPalette,\n            hasStroke: frame.hasStroke,\n            imageBitmap,\n            key: message.job.key,\n            maxStrokeWidth: frame.maxStrokeWidth,\n            png: frame.png,\n            requestId: message.requestId,\n            strokePalette: frame.strokePalette,\n            strokeWidths: frame.strokeWidths,\n            type: MaskPreparationWorkerMessageType.Complete,\n        };\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        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        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex`, `frameRate`,\n         * and optional `frameIndexOriginTime`. This is useful when inference was run\n         * on normalized frames and playback should snap detections to that grid.\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 assertMaskDimensions(data, 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        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.ceil(intersections[index]));\n                const right = Math.min(dimensions.width - 1, Math.floor(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    const MAX_ID_MASK_PALETTE_ENTRIES = 64;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...instructions.map(({ mask }) => mask.width));\n        const height = Math.max(...instructions.map(({ mask }) => mask.height));\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(Math.max(0, instruction.stroke.width), 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            const decodedMask = decodeCompressedRleMask(instruction.mask);\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                        data[y * width + x] = detectionMaskId;\n                    }\n                }\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\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    /**\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        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    const PNG_SIGNATURE = new Uint8Array([\n        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,\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 createMaskIdFrame(instructions) {\n        return createIdMaskFrame(materializeMaskInstructions(instructions));\n    }\n    async function createPngIdMaskFrame(instructions) {\n        const frame = createMaskIdFrame(instructions);\n        if (!frame) {\n            return undefined;\n        }\n        return {\n            ...frame,\n            png: await encodeGrayscalePng({\n                height: frame.height,\n                pixels: frame.data,\n                width: frame.width,\n            }),\n        };\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.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    async function encodeGrayscalePng(options) {\n        if (typeof CompressionStream === \"undefined\") {\n            throw new Error(\"CompressionStream is required to encode PNG ID masks.\");\n        }\n        const rawScanlines = createFilterlessPngScanlines(options);\n        const ihdr = new Uint8Array(13);\n        const ihdrView = new DataView(ihdr.buffer);\n        ihdrView.setUint32(0, options.width);\n        ihdrView.setUint32(4, options.height);\n        ihdr[8] = 8;\n        ihdr[9] = 0;\n        ihdr[10] = 0;\n        ihdr[11] = 0;\n        ihdr[12] = 0;\n        const compressed = new Uint8Array(await new Response(new Blob([rawScanlines])\n            .stream()\n            .pipeThrough(new CompressionStream(\"deflate\"))).arrayBuffer());\n        return concatUint8Arrays([\n            PNG_SIGNATURE,\n            createPngChunk(\"IHDR\", ihdr),\n            createPngChunk(\"IDAT\", compressed),\n            createPngChunk(\"IEND\", new Uint8Array(0)),\n        ]);\n    }\n    function createFilterlessPngScanlines(options) {\n        const rowStride = options.width + 1;\n        const scanlines = new Uint8Array(rowStride * options.height);\n        for (let y = 0; y < options.height; y += 1) {\n            const sourceOffset = y * options.width;\n            const targetOffset = y * rowStride;\n            scanlines[targetOffset] = 0;\n            scanlines.set(options.pixels.subarray(sourceOffset, sourceOffset + options.width), targetOffset + 1);\n        }\n        return scanlines;\n    }\n    function createPngChunk(type, data) {\n        const typeBytes = new TextEncoder().encode(type);\n        const chunk = new Uint8Array(12 + data.length);\n        const view = new DataView(chunk.buffer);\n        view.setUint32(0, data.length);\n        chunk.set(typeBytes, 4);\n        chunk.set(data, 8);\n        view.setUint32(8 + data.length, crc32(concatUint8Arrays([typeBytes, data])));\n        return chunk;\n    }\n    const crc32Table = createCrc32Table();\n    function createCrc32Table() {\n        const table = new Uint32Array(256);\n        for (let index = 0; index < table.length; index += 1) {\n            let value = index;\n            for (let bit = 0; bit < 8; bit += 1) {\n                value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;\n            }\n            table[index] = value >>> 0;\n        }\n        return table;\n    }\n    function crc32(bytes) {\n        let crc = 0xffffffff;\n        for (const byte of bytes) {\n            crc = crc32Table[(crc ^ byte) & 0xff] ^ (crc >>> 8);\n        }\n        return (crc ^ 0xffffffff) >>> 0;\n    }\n    function concatUint8Arrays(chunks) {\n        const totalLength = chunks.reduce((total, chunk) => total + chunk.length, 0);\n        const result = new Uint8Array(totalLength);\n        let offset = 0;\n        for (const chunk of chunks) {\n            result.set(chunk, offset);\n            offset += chunk.length;\n        }\n        return result;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"PngIdMask\"] = \"pngIdMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\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        void prepareMaskFrame(message);\n    });\n    async function prepareMaskFrame(message) {\n        try {\n            const pngIdMaskFrame = await createPngIdMaskWorkerResponse(message);\n            if (pngIdMaskFrame) {\n                workerScope.postMessage(pngIdMaskFrame, [\n                    pngIdMaskFrame.imageBitmap,\n                    pngIdMaskFrame.png.buffer,\n                    pngIdMaskFrame.fillPalette.buffer,\n                    pngIdMaskFrame.strokePalette.buffer,\n                    pngIdMaskFrame.strokeWidths.buffer,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const imageData = new ImageData(compositedFrame.data, compositedFrame.width, compositedFrame.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            const idMaskData = createMaskIdFrame(message.job.instructions)?.data;\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    imageBitmap,\n                    idMaskData,\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [...(idMaskData ? [idMaskData.buffer] : []), imageBitmap]);\n                return;\n            }\n            workerScope.postMessage({\n                idMaskData,\n                imageData,\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [...(idMaskData ? [idMaskData.buffer] : []), imageData.data.buffer]);\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    async function createPngIdMaskWorkerResponse(message) {\n        if (typeof Blob === \"undefined\" ||\n            typeof createImageBitmap === \"undefined\" ||\n            typeof CompressionStream === \"undefined\") {\n            return undefined;\n        }\n        let frame;\n        try {\n            frame = await createPngIdMaskFrame(message.job.instructions);\n        }\n        catch {\n            return undefined;\n        }\n        if (!frame) {\n            return undefined;\n        }\n        let imageBitmap;\n        try {\n            imageBitmap = await createImageBitmap(new Blob([frame.png], { type: \"image/png\" }));\n        }\n        catch {\n            return undefined;\n        }\n        return {\n            artifactKind: PreparedMaskFrameKind.PngIdMask,\n            fillPalette: frame.fillPalette,\n            hasStroke: frame.hasStroke,\n            imageBitmap,\n            key: message.job.key,\n            maxStrokeWidth: frame.maxStrokeWidth,\n            png: frame.png,\n            requestId: message.requestId,\n            strokePalette: frame.strokePalette,\n            strokeWidths: frame.strokeWidths,\n            type: MaskPreparationWorkerMessageType.Complete,\n        };\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;
@@ -10353,6 +10576,7 @@ async function prepareSessionDetections(options) {
         const writableSource = createWritableDetectionFrameSource({
             chunkDurationSeconds: appendableDetections.chunkDurationSeconds,
             datasetId: appendableDetections.datasetId,
+            live: appendableDetections.live,
             retention,
             store,
         });
@@ -10463,6 +10687,7 @@ async function createSessionWritableDetectionSource(options) {
     const writableSource = createWritableDetectionFrameSource({
         chunkDurationSeconds: options.appendable.chunkDurationSeconds,
         datasetId: options.appendable.datasetId,
+        live: options.appendable.live,
         retention,
         store,
     });
@@ -10711,6 +10936,7 @@ function resolveSessionStatus(renderer, activities, errorMessage) {
     return MediaSessionStatus.Ready;
 }
 
+const DISPLAY_RANGE_EPSILON_SECONDS = 1e-6;
 /**
  * Creates a renderer-owned media session for one browser media item.
  *
@@ -10803,6 +11029,19 @@ async function createMediaSession(options) {
             };
         };
         const initialPresentation = resolveRendererPresentation(currentPresentation);
+        let mediaCoordinateSpace = null;
+        /**
+         * Latches the media coordinate space as soon as the renderer reports real
+         * media dimensions, so session writes can be normalized into it.
+         */
+        const recordMediaCoordinateSpace = (state) => {
+            if (state.mediaWidth > 0 && state.mediaHeight > 0) {
+                mediaCoordinateSpace = {
+                    height: state.mediaHeight,
+                    width: state.mediaWidth,
+                };
+            }
+        };
         const renderer = await createMediaRenderer({
             ...options.renderer,
             ...sessionMedia.rendererSourceOption,
@@ -10829,6 +11068,7 @@ async function createMediaSession(options) {
             visibility: initialPresentation.visibility,
             onState(state) {
                 rendererState = state;
+                recordMediaCoordinateSpace(state);
                 options.renderer?.onState?.(state);
                 if (isDestroying) {
                     return;
@@ -10849,6 +11089,80 @@ async function createMediaSession(options) {
         });
         rendererState = renderer.getState();
         emitSessionState();
+        const autoRefresh = options.detections?.autoRefresh !== false;
+        let activeRefresh;
+        let queuedRefresh = false;
+        const runDetectionRefresh = () => {
+            activeRefresh = renderer
+                .refresh()
+                .catch(() => undefined)
+                .finally(() => {
+                activeRefresh = undefined;
+                if (queuedRefresh && !destroyed) {
+                    queuedRefresh = false;
+                    runDetectionRefresh();
+                }
+            });
+        };
+        /**
+         * Redraws once, collapsing requests that arrive during a redraw into a
+         * single follow-up.
+         */
+        const scheduleDetectionRefresh = () => {
+            if (!autoRefresh || destroyed) {
+                return;
+            }
+            if (activeRefresh) {
+                queuedRefresh = true;
+                return;
+            }
+            runDetectionRefresh();
+        };
+        /**
+         * Normalizes written frames into media space before they are stored, so a
+         * persisted dataset stays in one coordinate space. The renderer projects
+         * again on the read path for every other detection input, and re-projecting
+         * an already-projected frame is a no-op.
+         */
+        const projectWrittenFrames = (frames) => mediaCoordinateSpace
+            ? projectDetectionFrames(frames, mediaCoordinateSpace)
+            : frames;
+        /**
+         * Redraws once for a write that actually changed `range`.
+         *
+         * A write the source rejected as stale reports no change at all, and
+         * changes elsewhere on the timeline are already patched incrementally by
+         * the hot buffer, so forcing a render for either would only burn frames.
+         */
+        const requestDetectionRefresh = (source, previousVersion, range) => {
+            const changes = source.getChangesSince?.(previousVersion, [range]);
+            if (!changes || changes.requiresReload || changes.ranges.length > 0) {
+                scheduleDetectionRefresh();
+            }
+        };
+        const selectionLookaheadSeconds = resolveSelectionLookaheadSeconds(sessionDefaults.detectionBuffer, options.detections?.sources);
+        const hasOpenEndedFrame = (frames) => frames.some((frame) => frame.endTime === undefined);
+        /**
+         * The interval a write has to touch to change what is on screen.
+         *
+         * A frame written with an `endTime` is journaled exactly as it is selected,
+         * so comparing against the displayed instant is precise. A frame written
+         * without one is journaled as a point at its `mediaTime` but stays selected
+         * until a later frame supersedes it, so such a write can change the
+         * selection anywhere from the active frame's start onward. Nothing earlier
+         * than the active frame can, which is what keeps unrelated historical
+         * appends from forcing a render.
+         */
+        const getDisplayedRange = (includesOpenEndedFrame) => {
+            const { activeDetectionFrameTime, currentTime } = renderer.getState();
+            const startTime = includesOpenEndedFrame
+                ? Math.min(activeDetectionFrameTime ?? 0, currentTime)
+                : currentTime;
+            return {
+                endTime: currentTime + selectionLookaheadSeconds,
+                startTime: startTime - DISPLAY_RANGE_EPSILON_SECONDS,
+            };
+        };
         return {
             detectionSource: sessionDetections.detectionSource,
             media: sessionMedia.state,
@@ -10858,14 +11172,52 @@ async function createMediaSession(options) {
                     throw new Error("Media session has been destroyed.");
                 }
                 const appendableSource = resolveAppendableSource(sessionDetections, writeOptions);
-                return appendableSource.appendFrames(frames);
+                const previousVersion = appendableSource.getVersion();
+                const summary = await appendableSource.appendFrames(projectWrittenFrames(frames));
+                requestDetectionRefresh(appendableSource, previousVersion, getDisplayedRange(hasOpenEndedFrame(frames)));
+                return summary;
+            },
+            async appendLiveDetectionFrame(frame, writeOptions) {
+                if (destroyed) {
+                    throw new Error("Media session has been destroyed.");
+                }
+                const appendableSource = resolveAppendableSource(sessionDetections, writeOptions);
+                const previousVersion = appendableSource.getVersion();
+                const [projectedFrame = frame] = projectWrittenFrames([frame]);
+                const summary = await requireLiveDetectionSource(appendableSource).appendLiveFrame(projectedFrame);
+                // Live writes are gated on the displayed instant like any other write.
+                // A result the source dropped as stale changes nothing, and the hold
+                // always closes a live frame, so its journaled interval is exactly the
+                // interval it is selected for.
+                requestDetectionRefresh(appendableSource, previousVersion, getDisplayedRange(false));
+                return summary;
+            },
+            async finalizeDetectionCoverage(endTime, writeOptions) {
+                if (destroyed) {
+                    throw new Error("Media session has been destroyed.");
+                }
+                const appendableSource = resolveAppendableSource(sessionDetections, writeOptions);
+                const coverageEndTime = endTime ?? renderer.getState().duration;
+                if (coverageEndTime === null) {
+                    return null;
+                }
+                const previousVersion = appendableSource.getVersion();
+                const summary = await requireLiveDetectionSource(appendableSource).finalizeCoverage(coverageEndTime);
+                // Finalizing changes what the displayed instant selects: it closes a
+                // frame that was still open, or extends the last one to the end of
+                // media. Both are writes like any other and need the same redraw.
+                requestDetectionRefresh(appendableSource, previousVersion, getDisplayedRange(false));
+                return summary;
             },
             async replaceDetectionFrames(frames, writeOptions) {
                 if (destroyed) {
                     throw new Error("Media session has been destroyed.");
                 }
                 const appendableSource = resolveAppendableSource(sessionDetections, writeOptions);
-                return appendableSource.replaceFrames(frames);
+                const previousVersion = appendableSource.getVersion();
+                const summary = await appendableSource.replaceFrames(projectWrittenFrames(frames));
+                requestDetectionRefresh(appendableSource, previousVersion, getDisplayedRange(hasOpenEndedFrame(frames)));
+                return summary;
             },
             async clearDetectionFrames(writeOptions) {
                 if (destroyed) {
@@ -10975,9 +11327,45 @@ function resolveAppendableSourceOrNull(sessionDetections, options) {
         sessionDetections.appendableSources.values().next().value ??
         null);
 }
+/**
+ * How far past the displayed instant a write can still change the selection.
+ *
+ * Interval selection never looks ahead, but nearest-frame-index selection snaps
+ * to the closest inference frame, which may sit just after the displayed time.
+ * Composite sources can enable that mode per source, so the widest configured
+ * inference frame wins and plain interval sessions keep a point window.
+ */
+function resolveSelectionLookaheadSeconds(detectionBuffer, sources) {
+    const frameIntervals = [
+        detectionBuffer,
+        ...(sources ?? []).map((source) => source.sync),
+    ]
+        .filter((selection) => selection?.selectionMode ===
+        DetectionFrameSelectionMode.NearestFrameIndex)
+        .map((selection) => selection?.frameRate ?? detectionBuffer.frameRate)
+        .filter((frameRate) => frameRate !== undefined && frameRate > 0)
+        .map((frameRate) => 1 / frameRate);
+    return frameIntervals.length === 0
+        ? DISPLAY_RANGE_EPSILON_SECONDS
+        : Math.max(...frameIntervals);
+}
+/**
+ * Narrows an appendable source to the live ingestion capability.
+ *
+ * Live appends and coverage finalization are optional on
+ * `WritableDetectionFrameSource` so implementations written before they existed
+ * stay assignable. Such a source fails here with a clear message rather than a
+ * `TypeError` at the call site.
+ */
+function requireLiveDetectionSource(source) {
+    if (!source.appendLiveFrame || !source.finalizeCoverage) {
+        throw new Error("This detection source does not support live appends or coverage finalization.");
+    }
+    return source;
+}
 function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
 
-export { DetectionPostProcessingMode, DetectionTimelineOrigin, MediaNormalizationAudioCodec, MediaNormalizationContainer, MediaNormalizationFit, MediaNormalizationVideoCodec, MediaPreparationError, MediaProbeIssueCode, MediaProbeStatus, RenderPreparationArtifactFrameStatus, RenderPreparationArtifactKind, RenderPreparationExecutionMode, RenderPreparationMode, RenderPreparationWorkerStatus, createBrowserColdDetectionFrameStore, createChunkedDetectionFrameSource, createDefaultDetectionPostProcessingWorkerFactory, createDetectionPostProcessingPipeline, createImageUrlMediaSource, createMediaRenderer, createMediaSession, createMediaStreamRendererSource, createStaticImageMediaSource, normalizeMedia, normalizeMediaProgressively, prepareMedia, prepareMediaProgressively, probeMedia };
+export { DetectionPostProcessingMode, DetectionTimelineOrigin, MediaNormalizationAudioCodec, MediaNormalizationContainer, MediaNormalizationFit, MediaNormalizationVideoCodec, MediaPreparationError, MediaProbeIssueCode, MediaProbeStatus, MediaSourceError, RenderPreparationArtifactFrameStatus, RenderPreparationArtifactKind, RenderPreparationExecutionMode, RenderPreparationMode, RenderPreparationWorkerStatus, createBrowserColdDetectionFrameStore, createChunkedDetectionFrameSource, createDefaultDetectionPostProcessingWorkerFactory, createDetectionPostProcessingPipeline, createImageUrlMediaSource, createMediaRenderer, createMediaSession, createMediaStreamRendererSource, createStaticImageMediaSource, getMediaErrorKind, isMediaSourceError, normalizeMedia, normalizeMediaProgressively, prepareMedia, prepareMediaProgressively, probeMedia, toMediaSourceError };
 //# sourceMappingURL=index.js.map