supervision 0.2.1 → 0.2.2

package/dist/index.js

@@ -1,5 +1,5 @@
 import { copySortedDetectionFrames, detectionFrameOverlapsRange, projectDetectionFrameForTracking, createSortTracker, createOCSortTracker, createCBIoUTracker, createByteTrackTracker, MediaErrorKind, includeDefined, MediaSourceStatus, MediaRendererPlaybackState, MediaRendererFit, createDefaultAnnotationPresentation, createProjectedDetectionFrameSource, createArrayDetectionFrameSource, createBufferedDetectionTimeline, resolveAnnotationRendererPresentation, PlaybackGateReach, createIdleDetectionBufferState, MediaInteractionMode, decodeCompressedRleMask, createIdMaskFrame, encodeBinaryMask, rasterizePolygonToMask, resolveIdMaskPaletteId, decodeCompressedRleCounts, canReuseMaskStyleArtifacts, getBufferedDetectionTimelineFrameSnapshot, MAX_ID_MASK_PALETTE_ENTRIES, StrokeAlignment, BaseBoxStyle, centerRectToTopLeftRect, BoxShape, BaseFocusStyle, extractDetectionMaskRectRuns, AnnotationGestureStateKind, AnnotationHandleKind, getDetectionRect, DetectionPickTarget, createDetectionPickKey, rebaseDetectionPickToFrame, pickDetectionAtPoint, followDetectionPickAcrossFrames, haveSameDetectionPickIdentities, pickAnnotationHandle, getAnnotationHandles, LabelPlacement, BasePolygonStyle, BasePolylineStyle, BaseKeypointStyle, ShapeInstructionKind, sampleEllipseArc, resolveEllipseSegmentCount, KeypointMarkerShape, MarkerSizeSpace, MarkerShape, resolveMarkerGeometry, BaseInteractionStyle, DetectionInteractionState, writeIdMaskPaletteEntry, resolveIdMaskStrokeTexels, MAX_ID_MASK_STROKE_WIDTH, DetectionBufferStatus, resolveMaskStyleOpacity, pickDetectionByMaskId, BoxStrokeAlignment, RegionRendererMediaEffectKind, RegionRendererSourceKind, RegionRendererCoverageKind, RegionRendererSizeSpace, resolveStyleValue, resolveAnnotationStyleState, lightenColor, resolveAnnotationRendererStyleFields, annotationRendererKinds, createViewportController, MediaSessionMode, DetectionFrameRetentionMode, createMemoryColdDetectionFrameStore, createWritableDetectionFrameSource, createCompositeDetectionFrameSource, MediaSessionActivityStatus, MediaSessionActivityKind, MediaSessionStatus, createSourceAwarePresentation, projectDetectionFrames, DetectionFrameSelectionMode } from 'supervision-js-core';
-export { BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MarkerShape, MarkerSizeSpace, MaskRenderMode, MediaErrorKind, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, PlaybackGateReach, RegionRendererComposeMode, RegionRendererCoverageKind, RegionRendererMediaEffectKind, RegionRendererRegionKind, RegionRendererSizeSpace, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, TrackingGeometry, annotationRendererKinds, annotationRenderers, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createMemoryColdDetectionFrameStore, createOCSortTracker, createProjectedDetectionFrameSource, createSortTracker, createWritableDetectionFrameSource, detectionPostProcessors, normalizeDetectionClassName, pickDetectionAtPoint, projectDetectionFrame, projectDetectionFrameForTracking, projectDetectionFrames, resolveDetectionClassColorStyle } from 'supervision-js-core';
+export { BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BaseOrientedBoxStyle, BasePercentageBarStyle, 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, PercentageBarPlacement, PlaybackGateReach, RegionRendererComposeMode, RegionRendererCoverageKind, RegionRendererMediaEffectKind, RegionRendererRegionKind, RegionRendererSizeSpace, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, TrackingGeometry, annotationRendererKinds, annotationRenderers, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createMemoryColdDetectionFrameStore, createOCSortTracker, createProjectedDetectionFrameSource, createSortTracker, createWritableDetectionFrameSource, detectionPostProcessors, normalizeDetectionClassName, pickDetectionAtPoint, projectDetectionFrame, projectDetectionFrameForTracking, projectDetectionFrames, resolveDetectionClassColorStyle } from 'supervision-js-core';
 import { M as MediaSourceError, t as toMediaSourceError, r as resolveDisplayPixelRatio } from './video-engine-media-source-DR-x1UfK.js';
 export { c as createWebVideoEngineMediaRendererSource, g as getMediaErrorKind, i as isMediaSourceError, o as openWebVideoEngineMediaSource } from './video-engine-media-source-DR-x1UfK.js';
 
@@ -497,7 +497,7 @@ function getDetectionFrameDedupeKey(frame) {
         : `index:${frame.frameIndex}`;
 }
 
-const EMBEDDED_TRACKING_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /**\n     * Creates one stateful SORT tracker for a single ordered media sequence.\n     *\n     * Defaults, lifecycle semantics, and observation-only output mirror\n     * roboflow/trackers SORT. Motion predictions remain internal to association.\n     */\n    function createSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.25;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                const predicted = tracks.map((track) => track.predict(frameStep, frameRate));\n                const { matches, unmatchedDetections } = associateDetectionsToTracks(detections, predicted, minimumIouThreshold);\n                const trackerIds = new Map();\n                for (const match of matches) {\n                    const track = tracks[match.trackIndex];\n                    const detection = detections[match.detectionIndex];\n                    track.update(detection);\n                    if (track.trackerId === undefined &&\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        track.trackerId = nextTrackerId;\n                        nextTrackerId += 1;\n                    }\n                    if (track.trackerId !== undefined) {\n                        trackerIds.set(detection.detectionIndex, track.trackerId);\n                    }\n                }\n                for (const detectionIndex of unmatchedDetections) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection));\n                    }\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = trackerIds.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n    }\n    class KalmanBoxTrack {\n        consecutiveUpdates;\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        state;\n        covariance = identity(8);\n        constructor(detection, consecutiveUpdates = false) {\n            this.consecutiveUpdates = consecutiveUpdates;\n            this.state = [...rectToXyxy(detection.rect), 0, 0, 0, 0].map((value) => [\n                value,\n            ]);\n        }\n        predict(frameStep, frameRate) {\n            if (this.consecutiveUpdates && this.timeSinceUpdate > 0) {\n                this.successfulUpdates = 0;\n            }\n            const transition = identity(8);\n            for (let index = 0; index < 4; index += 1) {\n                transition[index][index + 4] = frameStep;\n            }\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), createProcessNoise(frameStep, frameRate));\n            // Python SORT counts update calls for the fixed-rate lost-track budget.\n            this.timeSinceUpdate += 1;\n            return stateToRect(this.state);\n        }\n        update(detection) {\n            const measurement = rectToXyxy(detection.rect).map((value) => [value]);\n            const observation = [\n                [1, 0, 0, 0, 0, 0, 0, 0],\n                [0, 1, 0, 0, 0, 0, 0, 0],\n                [0, 0, 1, 0, 0, 0, 0, 0],\n                [0, 0, 0, 1, 0, 0, 0, 0],\n            ];\n            const measurementNoise = scale(identity(4), 0.1);\n            const innovation = subtract(measurement, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(8), multiply(gain, observation));\n            // Joseph form matches the Python implementation and is more stable.\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, measurementNoise), transpose(gain)));\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getStateRect() {\n            return stateToRect(this.state);\n        }\n    }\n    function associateDetectionsToTracks(detections, predicted, minimumIouThreshold) {\n        if (predicted.length === 0 || detections.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetections: detections.map((_, index) => index),\n            };\n        }\n        // Python SORT associates all detections class-agnostically using standard IoU.\n        const scores = predicted.map((rect) => detections.map((detection) => intersectionOverUnion(rect, detection.rect)));\n        const candidateMatches = maximizeAssignment(scores);\n        const matches = [];\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of candidateMatches) {\n            if (scores[trackIndex][detectionIndex] < minimumIouThreshold)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetections: detections.flatMap((_, index) => matchedDetections.has(index) ? [] : [index]),\n        };\n    }\n    /** Hungarian assignment for a rectangular score matrix. */\n    function maximizeAssignment(scores) {\n        if (scores.length === 0 || scores[0]?.length === 0) {\n            return [];\n        }\n        const rowCount = scores.length;\n        const columnCount = scores[0].length;\n        const transposed = rowCount > columnCount;\n        const costs = transposed\n            ? Array.from({ length: columnCount }, (_, row) => Array.from({ length: rowCount }, (_, column) => 1 - scores[column][row]))\n            : scores.map((row) => row.map((score) => 1 - score));\n        const rows = costs.length;\n        const columns = costs[0].length;\n        const u = new Array(rows + 1).fill(0);\n        const v = new Array(columns + 1).fill(0);\n        const p = new Array(columns + 1).fill(0);\n        const way = new Array(columns + 1).fill(0);\n        for (let row = 1; row <= rows; row += 1) {\n            p[0] = row;\n            let column0 = 0;\n            const minValue = new Array(columns + 1).fill(Number.POSITIVE_INFINITY);\n            const used = new Array(columns + 1).fill(false);\n            do {\n                used[column0] = true;\n                const row0 = p[column0];\n                let delta = Number.POSITIVE_INFINITY;\n                let column1 = 0;\n                for (let column = 1; column <= columns; column += 1) {\n                    if (used[column])\n                        continue;\n                    const current = costs[row0 - 1][column - 1] - u[row0] - v[column];\n                    if (current < minValue[column]) {\n                        minValue[column] = current;\n                        way[column] = column0;\n                    }\n                    if (minValue[column] < delta) {\n                        delta = minValue[column];\n                        column1 = column;\n                    }\n                }\n                for (let column = 0; column <= columns; column += 1) {\n                    if (used[column]) {\n                        u[p[column]] += delta;\n                        v[column] -= delta;\n                    }\n                    else {\n                        minValue[column] -= delta;\n                    }\n                }\n                column0 = column1;\n            } while (p[column0] !== 0);\n            do {\n                const column1 = way[column0];\n                p[column0] = p[column1];\n                column0 = column1;\n            } while (column0 !== 0);\n        }\n        const assignments = [];\n        for (let column = 1; column <= columns; column += 1) {\n            if (p[column] === 0)\n                continue;\n            const row = p[column] - 1;\n            assignments.push(transposed ? [column - 1, row] : [row, column - 1]);\n        }\n        return assignments;\n    }\n    function rectToXyxy(rect) {\n        return [\n            rect.x - rect.width / 2,\n            rect.y - rect.height / 2,\n            rect.x + rect.width / 2,\n            rect.y + rect.height / 2,\n        ];\n    }\n    function stateToRect(state) {\n        // The Python XYXY estimator intentionally leaves corner velocities\n        // unconstrained. Normalize only at the browser Rect boundary so a crossing\n        // prediction cannot violate the positive-width/height storage contract.\n        const x1 = Math.min(state[0][0], state[2][0]);\n        const y1 = Math.min(state[1][0], state[3][0]);\n        const x2 = Math.max(state[0][0], state[2][0]);\n        const y2 = Math.max(state[1][0], state[3][0]);\n        return {\n            height: Math.max(Number.EPSILON, y2 - y1),\n            width: Math.max(Number.EPSILON, x2 - x1),\n            x: (x1 + x2) / 2,\n            y: (y1 + y2) / 2,\n        };\n    }\n    function createProcessNoise(frameStep, frameRate) {\n        if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n            return scale(identity(8), 0.01);\n        }\n        const result = Array.from({ length: 8 }, () => new Array(8).fill(0));\n        const dt2 = frameStep * frameStep;\n        const dt3 = dt2 * frameStep;\n        const dt4 = dt2 * dt2;\n        for (let index = 0; index < 4; index += 1) {\n            const velocityIndex = index + 4;\n            result[index][index] = (0.01 * dt4) / 4;\n            result[index][velocityIndex] = (0.01 * dt3) / 2;\n            result[velocityIndex][index] = (0.01 * dt3) / 2;\n            result[velocityIndex][velocityIndex] = 0.01 * dt2;\n        }\n        return result;\n    }\n    function intersectionOverUnion(left, right) {\n        const leftX = left.x - left.width / 2;\n        const leftY = left.y - left.height / 2;\n        const rightX = right.x - right.width / 2;\n        const rightY = right.y - right.height / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + left.width, rightX + right.width) -\n            Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + left.height, rightY + right.height) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = left.width * left.height + right.width * right.height - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n    function resolveFrameStep(current, previous) {\n        if (current === undefined || previous === undefined)\n            return 1;\n        return Math.max(1, current - previous);\n    }\n    function normalizePositiveInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 1) {\n            throw new Error(`${label} must be a positive integer.`);\n        }\n        return value;\n    }\n    function normalizeNonNegativeInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 0) {\n            throw new Error(`${label} must be a non-negative integer.`);\n        }\n        return value;\n    }\n    function normalizeUnitInterval$1(value, label) {\n        if (!Number.isFinite(value) || value < 0 || value > 1) {\n            throw new Error(`${label} must be between 0 and 1.`);\n        }\n    }\n    function identity(size) {\n        return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));\n    }\n    function scale(matrix, factor) {\n        return matrix.map((row) => row.map((value) => value * factor));\n    }\n    function transpose(matrix) {\n        return matrix[0].map((_, column) => matrix.map((row) => row[column]));\n    }\n    function add(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value + right[rowIndex][columnIndex]));\n    }\n    function subtract(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value - right[rowIndex][columnIndex]));\n    }\n    function multiply(left, right) {\n        return left.map((row) => right[0].map((_, column) => row.reduce((sum, value, index) => sum + value * right[index][column], 0)));\n    }\n    function inverse(matrix) {\n        const size = matrix.length;\n        const augmented = matrix.map((row, index) => [\n            ...row,\n            ...identity(size)[index],\n        ]);\n        for (let column = 0; column < size; column += 1) {\n            let pivot = column;\n            for (let row = column + 1; row < size; row += 1) {\n                if (Math.abs(augmented[row][column]) >\n                    Math.abs(augmented[pivot][column])) {\n                    pivot = row;\n                }\n            }\n            if (Math.abs(augmented[pivot][column]) < 1e-12) {\n                throw new Error(\"SORT Kalman covariance is singular.\");\n            }\n            [augmented[column], augmented[pivot]] = [\n                augmented[pivot],\n                augmented[column],\n            ];\n            const divisor = augmented[column][column];\n            augmented[column] = augmented[column].map((value) => value / divisor);\n            for (let row = 0; row < size; row += 1) {\n                if (row === column)\n                    continue;\n                const factor = augmented[row][column];\n                augmented[row] = augmented[row].map((value, index) => value - factor * augmented[column][index]);\n            }\n        }\n        return augmented.map((row) => row.slice(size));\n    }\n\n    /**\n     * Creates one stateful ByteTrack tracker for a single ordered media sequence.\n     *\n     * Defaults and two-stage association mirror roboflow/trackers ByteTrack at\n     * source commit 60b21c8a48676784085fbee455559f16b75a7c9a.\n     * Motion predictions remain internal; only observed detections receive IDs.\n     */\n    function createByteTrackTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.1;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    if ((detection.confidence ?? 1) >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const assignments = new Map();\n                const firstStage = associate(tracks, detections, highDetectionIndexes, minimumIouThreshold);\n                for (const match of firstStage.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                const remainingTracks = firstStage.unmatchedTrackIndexes.map((index) => tracks[index]);\n                const secondStage = associate(remainingTracks, detections, lowDetectionIndexes, minimumIouThreshold);\n                for (const match of secondStage.matches) {\n                    updateMatchedTrack(remainingTracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                // Only unmatched high-confidence observations can start a track.\n                for (const detectionIndex of firstStage.unmatchedDetectionIndexes) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection, true));\n                    }\n                }\n                // Confirmation is sticky once an ID has been allocated. An unmatched\n                // unconfirmed track is discarded immediately, as in Python ByteTrack.\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = assignments.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId;\n                nextTrackerId += 1;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function associate(tracks, detections, detectionIndexes, minimumIouThreshold) {\n        if (tracks.length === 0 || detectionIndexes.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetectionIndexes: [...detectionIndexes],\n                unmatchedTrackIndexes: tracks.map((_, index) => index),\n            };\n        }\n        const scores = tracks.map((track) => {\n            const predictedRect = track.getStateRect();\n            return detectionIndexes.map((detectionIndex) => intersectionOverUnion(predictedRect, detections[detectionIndex].rect));\n        });\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, localDetectionIndex] of maximizeAssignment(scores)) {\n            if (scores[trackIndex][localDetectionIndex] < minimumIouThreshold) {\n                continue;\n            }\n            const detectionIndex = detectionIndexes[localDetectionIndex];\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: detectionIndexes.filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: tracks.flatMap((_, index) => matchedTracks.has(index) ? [] : [index]),\n        };\n    }\n\n    function associateTrackingScores(scores, trackCount, detectionCount, minimumScore, acceptanceScores = scores) {\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of maximizeAssignment(scores)) {\n            if (acceptanceScores[trackIndex][detectionIndex] < minimumScore)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: Array.from({ length: detectionCount }, (_, index) => index).filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: Array.from({ length: trackCount }, (_, index) => index).filter((index) => !matchedTracks.has(index)),\n        };\n    }\n    function pairwiseIou(tracks, detections, bufferRatio = 0) {\n        return tracks.map((track) => detections.map((detection) => bufferedIntersectionOverUnion(track, detection, bufferRatio)));\n    }\n    function bufferedIntersectionOverUnion(left, right, bufferRatio) {\n        const leftWidth = left.width * (1 + 2 * bufferRatio);\n        const leftHeight = left.height * (1 + 2 * bufferRatio);\n        const rightWidth = right.width * (1 + 2 * bufferRatio);\n        const rightHeight = right.height * (1 + 2 * bufferRatio);\n        const leftX = left.x - leftWidth / 2;\n        const leftY = left.y - leftHeight / 2;\n        const rightX = right.x - rightWidth / 2;\n        const rightY = right.y - rightHeight / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + leftWidth, rightX + rightWidth) - Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + leftHeight, rightY + rightHeight) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = leftWidth * leftHeight + rightWidth * rightHeight - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n\n    /**\n     * Kalman state estimator shared by the browser C-BIoU and OC-SORT ports.\n     * Its layouts, covariance update, and gap-scaled constant-velocity model\n     * mirror roboflow/trackers at 60b21c8.\n     */\n    class TrackingKalmanEstimator {\n        representation;\n        dimension;\n        measurementDimension = 4;\n        covariance;\n        measurementNoise = identity(4);\n        processNoise;\n        state;\n        baselineProcessNoise;\n        positionIndexes;\n        velocityIndexes;\n        constructor(initialRect, representation) {\n            this.representation = representation;\n            const measurement = rectToMeasurement(initialRect, representation);\n            this.dimension = representation === \"xcycsr\" ? 7 : 8;\n            this.positionIndexes =\n                representation === \"xcycsr\" ? [0, 1, 2] : [0, 1, 2, 3];\n            this.velocityIndexes =\n                representation === \"xcycsr\" ? [4, 5, 6] : [4, 5, 6, 7];\n            this.state = Array.from({ length: this.dimension }, (_, index) => [\n                measurement[index] ?? 0,\n            ]);\n            this.covariance = identity(this.dimension);\n            this.processNoise = identity(this.dimension);\n            this.baselineProcessNoise = identity(this.dimension);\n        }\n        predict(frameStep, frameRate) {\n            if (this.representation === \"xcycsr\" &&\n                this.state[2][0] + frameStep * this.state[6][0] <= 0) {\n                this.state[6][0] = 0;\n            }\n            const transition = identity(this.dimension);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                transition[positionIndex][this.velocityIndexes[index]] = frameStep;\n            });\n            this.processNoise = this.createProcessNoise(frameStep, frameRate);\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), this.processNoise);\n        }\n        update(rect) {\n            this.updateMeasurement(rectToMeasurement(rect, this.representation));\n        }\n        updateMeasurement(measurement) {\n            const observation = Array.from({ length: 4 }, (_, row) => Array.from({ length: this.dimension }, (_, column) => row === column ? 1 : 0));\n            const measurementColumn = measurement.map((value) => [value]);\n            const innovation = subtract(measurementColumn, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), this.measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(this.dimension), multiply(gain, observation));\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, this.measurementNoise), transpose(gain)));\n        }\n        getRect() {\n            return measurementToRect(this.state.slice(0, 4).map((row) => row[0]), this.representation);\n        }\n        setCovariances(options) {\n            if (options.covariance)\n                this.covariance = clone(options.covariance);\n            if (options.measurementNoise) {\n                this.measurementNoise = clone(options.measurementNoise);\n            }\n            if (options.processNoise) {\n                this.processNoise = clone(options.processNoise);\n                this.baselineProcessNoise = clone(options.processNoise);\n            }\n        }\n        snapshot() {\n            return {\n                covariance: clone(this.covariance),\n                measurementNoise: clone(this.measurementNoise),\n                processNoise: clone(this.processNoise),\n                state: clone(this.state),\n            };\n        }\n        restore(snapshot) {\n            this.covariance = clone(snapshot.covariance);\n            this.measurementNoise = clone(snapshot.measurementNoise);\n            this.processNoise = clone(snapshot.processNoise);\n            this.state = clone(snapshot.state);\n        }\n        createProcessNoise(frameStep, frameRate) {\n            if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n                return clone(this.baselineProcessNoise);\n            }\n            const result = Array.from({ length: this.dimension }, () => new Array(this.dimension).fill(0));\n            const dt2 = frameStep * frameStep;\n            const dt3 = dt2 * frameStep;\n            const dt4 = dt2 * dt2;\n            const kinematicIndexes = new Set([\n                ...this.positionIndexes,\n                ...this.velocityIndexes,\n            ]);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                const velocityIndex = this.velocityIndexes[index];\n                const accelerationVariance = this.baselineProcessNoise[velocityIndex][velocityIndex];\n                result[positionIndex][positionIndex] = (accelerationVariance * dt4) / 4;\n                result[positionIndex][velocityIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][positionIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][velocityIndex] = accelerationVariance * dt2;\n            });\n            for (let index = 0; index < this.dimension; index += 1) {\n                if (!kinematicIndexes.has(index)) {\n                    result[index][index] = this.baselineProcessNoise[index][index];\n                }\n            }\n            return result;\n        }\n    }\n    function rectToMeasurement(rect, representation) {\n        if (representation === \"xcycwh\") {\n            return [rect.x, rect.y, rect.width, rect.height];\n        }\n        return [\n            rect.x,\n            rect.y,\n            rect.width * rect.height,\n            rect.width / (rect.height + 1e-6),\n        ];\n    }\n    function measurementToRect(measurement, representation) {\n        const [x, y, third, fourth] = measurement;\n        if (representation === \"xcycwh\") {\n            return {\n                height: Math.max(1e-3, fourth),\n                width: Math.max(1e-3, third),\n                x,\n                y,\n            };\n        }\n        const width = Math.sqrt(third * fourth);\n        const height = width === 0 ? 0 : third / width;\n        return {\n            height: Math.max(Number.EPSILON, height),\n            width: Math.max(Number.EPSILON, width),\n            x,\n            y,\n        };\n    }\n    function diagonal(values) {\n        return values.map((value, row) => values.map((_, column) => (row === column ? value : 0)));\n    }\n    function scaleMatrix(matrix, factor) {\n        return scale(matrix, factor);\n    }\n    function clone(matrix) {\n        return matrix.map((row) => [...row]);\n    }\n\n    const MINIMUM_DETECTION_CONFIDENCE = 0.1;\n    class CBIoUTrack {\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        estimator;\n        constructor(initial) {\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycwh\");\n            this.setInitialNoise(initial.rect.width, initial.rect.height);\n        }\n        predict(frameStep, frameRate) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                processNoise: this.buildProcessNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.predict(frameStep, frameRate);\n            this.clampState();\n            this.timeSinceUpdate += 1;\n        }\n        update(detection) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                measurementNoise: this.buildMeasurementNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.update(detection.rect);\n            this.clampState();\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        setInitialNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            this.estimator.setCovariances({\n                covariance: diagonal([\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                ]),\n                measurementNoise: this.buildMeasurementNoise(width, height),\n                processNoise: this.buildProcessNoise(width, height),\n            });\n        }\n        buildProcessNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            return diagonal([\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n            ]);\n        }\n        buildMeasurementNoise(width, height) {\n            const sigmaMeasurement = 0.05;\n            return diagonal([\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n            ]);\n        }\n        clampState() {\n            this.estimator.state[2][0] = Math.max(this.estimator.state[2][0], 1e-3);\n            this.estimator.state[3][0] = Math.max(this.estimator.state[3][0], 1e-3);\n        }\n    }\n    /** Creates the detection-only C-BIoU implementation from roboflow/trackers. */\n    function createCBIoUTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ?? 0.2;\n        const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ?? 0.5;\n        const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ?? 0.3;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const instantFirstFrameActivation = options.instantFirstFrameActivation ?? true;\n        const bufferRatioFirst = options.bufferRatioFirst ?? 0.3;\n        const bufferRatioSecond = options.bufferRatioSecond ?? 0.5;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThresholdFirstAssociation, \"minimumIouThresholdFirstAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdSecondAssociation, \"minimumIouThresholdSecondAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdUnconfirmedAssociation, \"minimumIouThresholdUnconfirmedAssociation\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        if (!Number.isFinite(bufferRatioFirst) || bufferRatioFirst < 0) {\n            throw new Error(\"bufferRatioFirst must be a finite non-negative value.\");\n        }\n        if (!Number.isFinite(bufferRatioSecond) || bufferRatioSecond < 0) {\n            throw new Error(\"bufferRatioSecond must be a finite non-negative value.\");\n        }\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let frameId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                frameId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                frameId += 1;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    const confidence = detection.confidence ?? 1;\n                    if (confidence >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else if (confidence > MINIMUM_DETECTION_CONFIDENCE) {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const confirmed = [];\n                const unconfirmed = [];\n                const lost = [];\n                for (const track of tracks) {\n                    if (track.timeSinceUpdate > 1)\n                        lost.push(track);\n                    else if (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        confirmed.push(track);\n                    }\n                    else\n                        unconfirmed.push(track);\n                }\n                const assignments = new Map();\n                const pool = [...confirmed, ...lost];\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const firstScores = pairwiseIou(pool.map((track) => track.getRect()), highDetections.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (highDetections[index].confidence ?? 1)));\n                const firstAssociation = associateTrackingScores(firstScores, pool.length, highDetections.length, minimumIouThresholdFirstAssociation);\n                for (const match of firstAssociation.matches) {\n                    updateMatchedTrack(pool[match.trackIndex], highDetections[match.detectionIndex], assignments);\n                }\n                const remainingTracked = firstAssociation.unmatchedTrackIndexes\n                    .map((index) => pool[index])\n                    .filter((track) => track.timeSinceUpdate === 1);\n                const lowDetections = lowDetectionIndexes.map((index) => detections[index]);\n                const secondScores = pairwiseIou(remainingTracked.map((track) => track.getRect()), lowDetections.map((detection) => detection.rect), bufferRatioSecond);\n                const secondAssociation = associateTrackingScores(secondScores, remainingTracked.length, lowDetections.length, minimumIouThresholdSecondAssociation);\n                for (const match of secondAssociation.matches) {\n                    updateMatchedTrack(remainingTracked[match.trackIndex], lowDetections[match.detectionIndex], assignments);\n                }\n                let unmatchedHighLocal = [...firstAssociation.unmatchedDetectionIndexes];\n                let unmatchedUnconfirmed = unconfirmed.map((_, index) => index);\n                if (unconfirmed.length > 0 && unmatchedHighLocal.length > 0) {\n                    const remainingHigh = unmatchedHighLocal.map((index) => highDetections[index]);\n                    const unconfirmedScores = pairwiseIou(unconfirmed.map((track) => track.getRect()), remainingHigh.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (remainingHigh[index].confidence ?? 1)));\n                    const unconfirmedAssociation = associateTrackingScores(unconfirmedScores, unconfirmed.length, remainingHigh.length, minimumIouThresholdUnconfirmedAssociation);\n                    unmatchedUnconfirmed = unconfirmedAssociation.unmatchedTrackIndexes;\n                    for (const match of unconfirmedAssociation.matches) {\n                        updateMatchedTrack(unconfirmed[match.trackIndex], remainingHigh[match.detectionIndex], assignments);\n                    }\n                    unmatchedHighLocal =\n                        unconfirmedAssociation.unmatchedDetectionIndexes.map((index) => unmatchedHighLocal[index]);\n                }\n                const unmatchedUnconfirmedTracks = new Set(unmatchedUnconfirmed.map((index) => unconfirmed[index]));\n                tracks = tracks.filter((track) => !unmatchedUnconfirmedTracks.has(track));\n                for (const localIndex of unmatchedHighLocal) {\n                    const detection = highDetections[localIndex];\n                    if ((detection.confidence ?? 1) < trackActivationThreshold)\n                        continue;\n                    const track = new CBIoUTrack(detection);\n                    if (frameId === 1 && instantFirstFrameActivation) {\n                        track.trackerId = nextTrackerId++;\n                        assignments.set(detection.detectionIndex, track.trackerId);\n                    }\n                    tracks.push(track);\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.timeSinceUpdate === 0 ||\n                        track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames));\n                return createUpdate(detections, assignments, tracks);\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId++;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function createUpdate(detections, assignments, tracks) {\n        const resolvedAssignments = detections.flatMap((detection) => {\n            const trackerId = assignments.get(detection.detectionIndex);\n            return trackerId === undefined\n                ? []\n                : [{ detectionIndex: detection.detectionIndex, trackerId }];\n        });\n        return {\n            activeTrackCount: tracks.length,\n            assignments: resolvedAssignments,\n            confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined)\n                .length,\n        };\n    }\n\n    class OCSortTrack {\n        deltaT;\n        age = 0;\n        lastObservation;\n        trackerId;\n        successfulConsecutiveUpdates = 0;\n        timeSinceUpdate = 0;\n        velocity;\n        frozenState;\n        observed = true;\n        observations = new Map();\n        estimator;\n        constructor(initial, deltaT) {\n            this.deltaT = deltaT;\n            this.lastObservation = initial;\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycsr\");\n            this.configureNoise();\n        }\n        predict(frameStep, frameRate) {\n            if (this.observed && this.timeSinceUpdate > 0) {\n                this.frozenState = this.estimator.snapshot();\n                this.observed = false;\n            }\n            this.estimator.predict(frameStep, frameRate);\n            if (this.timeSinceUpdate > 0) {\n                this.successfulConsecutiveUpdates = 0;\n            }\n            this.timeSinceUpdate += 1;\n            this.age += 1;\n        }\n        update(detection, frameStep, frameRate) {\n            const previous = this.getPreviousObservation();\n            if (previous) {\n                this.velocity = computeVelocity(previous, detection);\n            }\n            if (!this.observed && this.frozenState) {\n                this.unfreeze(detection, frameStep, frameRate);\n            }\n            this.estimator.update(detection.rect);\n            this.observed = true;\n            this.timeSinceUpdate = 0;\n            this.successfulConsecutiveUpdates += 1;\n            this.lastObservation = detection;\n            this.observations.set(this.age, detection);\n            const cutoff = this.age - this.deltaT;\n            for (const age of this.observations.keys()) {\n                if (age < cutoff)\n                    this.observations.delete(age);\n            }\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        getPreviousObservation() {\n            if (this.observations.size === 0)\n                return undefined;\n            for (let index = 0; index < this.deltaT; index += 1) {\n                const delta = this.deltaT - index;\n                const observation = this.observations.get(this.age - delta);\n                if (observation)\n                    return observation;\n            }\n            const latestAge = Math.max(...this.observations.keys());\n            return this.observations.get(latestAge);\n        }\n        configureNoise() {\n            const measurementNoise = identity(4);\n            for (let index = 2; index < 4; index += 1) {\n                measurementNoise[index][index] *= 10;\n            }\n            const covariance = scaleMatrix(identity(7), 10);\n            for (let index = 4; index < 7; index += 1) {\n                covariance[index][index] *= 1000;\n            }\n            const processNoise = identity(7);\n            processNoise[6][6] *= 0.01;\n            for (let index = 4; index < 7; index += 1) {\n                processNoise[index][index] *= 0.01;\n            }\n            this.estimator.setCovariances({\n                covariance,\n                measurementNoise,\n                processNoise,\n            });\n        }\n        unfreeze(detection, frameStep, frameRate) {\n            if (!this.frozenState || this.timeSinceUpdate === 0)\n                return;\n            this.estimator.restore(this.frozenState);\n            const timeGap = this.timeSinceUpdate;\n            const start = rectToMeasurement(this.lastObservation.rect, \"xcycsr\");\n            const end = rectToMeasurement(detection.rect, \"xcycsr\");\n            const startWidth = Math.sqrt(start[2] * start[3]);\n            const startHeight = start[3] === 0 ? 0 : Math.sqrt(start[2] / start[3]);\n            const endWidth = Math.sqrt(end[2] * end[3]);\n            const endHeight = end[3] === 0 ? 0 : Math.sqrt(end[2] / end[3]);\n            for (let index = 0; index < timeGap; index += 1) {\n                const progress = (index + 1) / timeGap;\n                const x = start[0] + progress * (end[0] - start[0]);\n                const y = start[1] + progress * (end[1] - start[1]);\n                const width = startWidth + progress * (endWidth - startWidth);\n                const height = startHeight + progress * (endHeight - startHeight);\n                this.estimator.updateMeasurement([x, y, width * height, width / height]);\n                if (index < timeGap - 1) {\n                    this.estimator.predict(frameStep, frameRate);\n                }\n            }\n            this.frozenState = undefined;\n        }\n    }\n    /** Creates the observation-centric SORT implementation from roboflow/trackers. */\n    function createOCSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        const directionConsistencyWeight = options.directionConsistencyWeight ?? 0.2;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const deltaT = normalizePositiveInteger$1(options.deltaT ?? 3, \"deltaT\");\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(directionConsistencyWeight, \"directionConsistencyWeight\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let frameCount = 0;\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                frameCount = 0;\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                // Match roboflow/trackers: an empty stream before any track exists is\n                // not part of OC-SORT's early-sequence activation window.\n                if (tracks.length === 0 && detections.length === 0) {\n                    return {\n                        activeTrackCount: 0,\n                        assignments: [],\n                        confirmedTrackCount: 0,\n                    };\n                }\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = detections.flatMap((detection, index) => detection.confidence === undefined ||\n                    detection.confidence >= highConfidenceDetectionThreshold\n                    ? [index]\n                    : []);\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const iouScores = pairwiseIou(tracks.map((track) => track.getRect()), highDetections.map((detection) => detection.rect));\n                const combinedScores = iouScores.map((row, trackIndex) => row.map((iou, detectionIndex) => {\n                    if (directionConsistencyWeight === 0)\n                        return iou;\n                    return (iou +\n                        directionConsistencyWeight *\n                            directionConsistency(tracks[trackIndex], highDetections[detectionIndex]) *\n                            (highDetections[detectionIndex].confidence ?? 1));\n                }));\n                const primary = associateTrackingScores(combinedScores, tracks.length, highDetections.length, minimumIouThreshold, iouScores);\n                const assignments = new Map();\n                for (const match of primary.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], highDetections[match.detectionIndex], assignments, frameStep);\n                }\n                let remainingHigh = [...primary.unmatchedDetectionIndexes];\n                if (primary.unmatchedTrackIndexes.length > 0 &&\n                    remainingHigh.length > 0) {\n                    const unmatchedTracks = primary.unmatchedTrackIndexes.map((index) => tracks[index]);\n                    const unmatchedDetections = remainingHigh.map((index) => highDetections[index]);\n                    const recoveryScores = pairwiseIou(unmatchedTracks.map((track) => track.lastObservation.rect), unmatchedDetections.map((detection) => detection.rect));\n                    const recovery = associateTrackingScores(recoveryScores, unmatchedTracks.length, unmatchedDetections.length, minimumIouThreshold);\n                    for (const match of recovery.matches) {\n                        updateMatchedTrack(unmatchedTracks[match.trackIndex], unmatchedDetections[match.detectionIndex], assignments, frameStep);\n                    }\n                    remainingHigh = recovery.unmatchedDetectionIndexes.map((index) => remainingHigh[index]);\n                }\n                for (const localIndex of remainingHigh) {\n                    tracks.push(new OCSortTrack(highDetections[localIndex], deltaT));\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate);\n                frameCount += 1;\n                const resolvedAssignments = detections.flatMap((detection) => {\n                    const trackerId = assignments.get(detection.detectionIndex);\n                    return trackerId === undefined\n                        ? []\n                        : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                });\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: resolvedAssignments,\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments, frameStep) {\n            track.update(detection, frameStep, frameRate);\n            const earlySequence = frameCount <= minimumConsecutiveFrames;\n            const shouldEmit = (earlySequence && track.timeSinceUpdate === 0) ||\n                track.successfulConsecutiveUpdates >= minimumConsecutiveFrames;\n            if (shouldEmit) {\n                if (track.trackerId === undefined) {\n                    track.trackerId = nextTrackerId++;\n                }\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function computeVelocity(previous, current) {\n        const deltaX = current.rect.x - previous.rect.x;\n        const deltaY = current.rect.y - previous.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        return { x: deltaX / norm, y: deltaY / norm };\n    }\n    function directionConsistency(track, detection) {\n        if (!track.velocity)\n            return 0;\n        const reference = track.getPreviousObservation() ?? track.lastObservation;\n        const deltaX = detection.rect.x - reference.rect.x;\n        const deltaY = detection.rect.y - reference.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        const cosine = Math.max(-1, Math.min(1, track.velocity.x * (deltaX / norm) + track.velocity.y * (deltaY / norm)));\n        const angle = Math.acos(cosine);\n        return (Math.PI / 2 - Math.abs(angle)) / Math.PI;\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createSortTracker(options = {}) {\n        return createSortTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createByteTrackTracker(options = {}) {\n        return createByteTrackTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createCBIoUTracker(options = {}) {\n        return createCBIoUTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createOCSortTracker(options = {}) {\n        return createOCSortTracker$1(options);\n    }\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read, or was refused before any read. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, and a gate that stops one has to bound its own wait\n     * or a producer nothing answers for never runs again.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        /**\n         * The picture is waiting on media the source has not handed over yet, which\n         * is the bytes and their decode rather than anything downstream of them.\n         * `PlaybackBuffering` is what a transport reports once it has already\n         * stopped; this is reported from the read itself, including the reads a seek\n         * makes while the transport still reads as paused.\n         */\n        MediaSessionActivityKind[\"MediaSourceReading\"] = \"mediaSourceReading\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        /**\n         * The render-preparation gate held the picture for artifacts that never\n         * arrived and let it go. Nothing is blocked: the frames reaching the screen\n         * are the ones whose artifacts were given up on. What is waited on is\n         * preparation finishing another frame, which is what lets the gate hold the\n         * picture again; `RenderPreparing` covers the holds that are running.\n         */\n        MediaSessionActivityKind[\"RenderPreparationAbandoned\"] = \"renderPreparationAbandoned\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    let tracker;\n    self.addEventListener(\"message\", (event) => {\n        const request = event.data;\n        try {\n            let response;\n            if (request.type === \"configure\") {\n                switch (request.processor.algorithm) {\n                    case \"bytetrack\":\n                        tracker = createByteTrackTracker(request.processor.options);\n                        break;\n                    case \"cbiou\":\n                        tracker = createCBIoUTracker(request.processor.options);\n                        break;\n                    case \"ocsort\":\n                        tracker = createOCSortTracker(request.processor.options);\n                        break;\n                    default:\n                        tracker = createSortTracker(request.processor.options);\n                }\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else if (request.type === \"reset\") {\n                tracker?.reset();\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else {\n                if (!tracker) {\n                    throw new Error(\"Tracking worker is not configured.\");\n                }\n                const startedAt = performance.now();\n                const update = tracker.update(request.detections, request.frameIndex);\n                response = {\n                    ...update,\n                    durationMs: performance.now() - startedAt,\n                    requestId: request.requestId,\n                    type: \"success\",\n                };\n            }\n            self.postMessage(response);\n        }\n        catch (error) {\n            self.postMessage({\n                message: error instanceof Error ? error.message : \"Tracking worker failed.\",\n                requestId: request.requestId,\n                type: \"error\",\n            });\n        }\n    });\n\n})();";
+const EMBEDDED_TRACKING_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /**\n     * Creates one stateful SORT tracker for a single ordered media sequence.\n     *\n     * Defaults, lifecycle semantics, and observation-only output mirror\n     * roboflow/trackers SORT. Motion predictions remain internal to association.\n     */\n    function createSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.25;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                const predicted = tracks.map((track) => track.predict(frameStep, frameRate));\n                const { matches, unmatchedDetections } = associateDetectionsToTracks(detections, predicted, minimumIouThreshold);\n                const trackerIds = new Map();\n                for (const match of matches) {\n                    const track = tracks[match.trackIndex];\n                    const detection = detections[match.detectionIndex];\n                    track.update(detection);\n                    if (track.trackerId === undefined &&\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        track.trackerId = nextTrackerId;\n                        nextTrackerId += 1;\n                    }\n                    if (track.trackerId !== undefined) {\n                        trackerIds.set(detection.detectionIndex, track.trackerId);\n                    }\n                }\n                for (const detectionIndex of unmatchedDetections) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection));\n                    }\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = trackerIds.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n    }\n    class KalmanBoxTrack {\n        consecutiveUpdates;\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        state;\n        covariance = identity(8);\n        constructor(detection, consecutiveUpdates = false) {\n            this.consecutiveUpdates = consecutiveUpdates;\n            this.state = [...rectToXyxy(detection.rect), 0, 0, 0, 0].map((value) => [\n                value,\n            ]);\n        }\n        predict(frameStep, frameRate) {\n            if (this.consecutiveUpdates && this.timeSinceUpdate > 0) {\n                this.successfulUpdates = 0;\n            }\n            const transition = identity(8);\n            for (let index = 0; index < 4; index += 1) {\n                transition[index][index + 4] = frameStep;\n            }\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), createProcessNoise(frameStep, frameRate));\n            // Python SORT counts update calls for the fixed-rate lost-track budget.\n            this.timeSinceUpdate += 1;\n            return stateToRect(this.state);\n        }\n        update(detection) {\n            const measurement = rectToXyxy(detection.rect).map((value) => [value]);\n            const observation = [\n                [1, 0, 0, 0, 0, 0, 0, 0],\n                [0, 1, 0, 0, 0, 0, 0, 0],\n                [0, 0, 1, 0, 0, 0, 0, 0],\n                [0, 0, 0, 1, 0, 0, 0, 0],\n            ];\n            const measurementNoise = scale(identity(4), 0.1);\n            const innovation = subtract(measurement, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(8), multiply(gain, observation));\n            // Joseph form matches the Python implementation and is more stable.\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, measurementNoise), transpose(gain)));\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getStateRect() {\n            return stateToRect(this.state);\n        }\n    }\n    function associateDetectionsToTracks(detections, predicted, minimumIouThreshold) {\n        if (predicted.length === 0 || detections.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetections: detections.map((_, index) => index),\n            };\n        }\n        // Python SORT associates all detections class-agnostically using standard IoU.\n        const scores = predicted.map((rect) => detections.map((detection) => intersectionOverUnion(rect, detection.rect)));\n        const candidateMatches = maximizeAssignment(scores);\n        const matches = [];\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of candidateMatches) {\n            if (scores[trackIndex][detectionIndex] < minimumIouThreshold)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetections: detections.flatMap((_, index) => matchedDetections.has(index) ? [] : [index]),\n        };\n    }\n    /** Hungarian assignment for a rectangular score matrix. */\n    function maximizeAssignment(scores) {\n        if (scores.length === 0 || scores[0]?.length === 0) {\n            return [];\n        }\n        const rowCount = scores.length;\n        const columnCount = scores[0].length;\n        const transposed = rowCount > columnCount;\n        const costs = transposed\n            ? Array.from({ length: columnCount }, (_, row) => Array.from({ length: rowCount }, (_, column) => 1 - scores[column][row]))\n            : scores.map((row) => row.map((score) => 1 - score));\n        const rows = costs.length;\n        const columns = costs[0].length;\n        const u = new Array(rows + 1).fill(0);\n        const v = new Array(columns + 1).fill(0);\n        const p = new Array(columns + 1).fill(0);\n        const way = new Array(columns + 1).fill(0);\n        for (let row = 1; row <= rows; row += 1) {\n            p[0] = row;\n            let column0 = 0;\n            const minValue = new Array(columns + 1).fill(Number.POSITIVE_INFINITY);\n            const used = new Array(columns + 1).fill(false);\n            do {\n                used[column0] = true;\n                const row0 = p[column0];\n                let delta = Number.POSITIVE_INFINITY;\n                let column1 = 0;\n                for (let column = 1; column <= columns; column += 1) {\n                    if (used[column])\n                        continue;\n                    const current = costs[row0 - 1][column - 1] - u[row0] - v[column];\n                    if (current < minValue[column]) {\n                        minValue[column] = current;\n                        way[column] = column0;\n                    }\n                    if (minValue[column] < delta) {\n                        delta = minValue[column];\n                        column1 = column;\n                    }\n                }\n                for (let column = 0; column <= columns; column += 1) {\n                    if (used[column]) {\n                        u[p[column]] += delta;\n                        v[column] -= delta;\n                    }\n                    else {\n                        minValue[column] -= delta;\n                    }\n                }\n                column0 = column1;\n            } while (p[column0] !== 0);\n            do {\n                const column1 = way[column0];\n                p[column0] = p[column1];\n                column0 = column1;\n            } while (column0 !== 0);\n        }\n        const assignments = [];\n        for (let column = 1; column <= columns; column += 1) {\n            if (p[column] === 0)\n                continue;\n            const row = p[column] - 1;\n            assignments.push(transposed ? [column - 1, row] : [row, column - 1]);\n        }\n        return assignments;\n    }\n    function rectToXyxy(rect) {\n        return [\n            rect.x - rect.width / 2,\n            rect.y - rect.height / 2,\n            rect.x + rect.width / 2,\n            rect.y + rect.height / 2,\n        ];\n    }\n    function stateToRect(state) {\n        // The Python XYXY estimator intentionally leaves corner velocities\n        // unconstrained. Normalize only at the browser Rect boundary so a crossing\n        // prediction cannot violate the positive-width/height storage contract.\n        const x1 = Math.min(state[0][0], state[2][0]);\n        const y1 = Math.min(state[1][0], state[3][0]);\n        const x2 = Math.max(state[0][0], state[2][0]);\n        const y2 = Math.max(state[1][0], state[3][0]);\n        return {\n            height: Math.max(Number.EPSILON, y2 - y1),\n            width: Math.max(Number.EPSILON, x2 - x1),\n            x: (x1 + x2) / 2,\n            y: (y1 + y2) / 2,\n        };\n    }\n    function createProcessNoise(frameStep, frameRate) {\n        if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n            return scale(identity(8), 0.01);\n        }\n        const result = Array.from({ length: 8 }, () => new Array(8).fill(0));\n        const dt2 = frameStep * frameStep;\n        const dt3 = dt2 * frameStep;\n        const dt4 = dt2 * dt2;\n        for (let index = 0; index < 4; index += 1) {\n            const velocityIndex = index + 4;\n            result[index][index] = (0.01 * dt4) / 4;\n            result[index][velocityIndex] = (0.01 * dt3) / 2;\n            result[velocityIndex][index] = (0.01 * dt3) / 2;\n            result[velocityIndex][velocityIndex] = 0.01 * dt2;\n        }\n        return result;\n    }\n    function intersectionOverUnion(left, right) {\n        const leftX = left.x - left.width / 2;\n        const leftY = left.y - left.height / 2;\n        const rightX = right.x - right.width / 2;\n        const rightY = right.y - right.height / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + left.width, rightX + right.width) -\n            Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + left.height, rightY + right.height) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = left.width * left.height + right.width * right.height - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n    function resolveFrameStep(current, previous) {\n        if (current === undefined || previous === undefined)\n            return 1;\n        return Math.max(1, current - previous);\n    }\n    function normalizePositiveInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 1) {\n            throw new Error(`${label} must be a positive integer.`);\n        }\n        return value;\n    }\n    function normalizeNonNegativeInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 0) {\n            throw new Error(`${label} must be a non-negative integer.`);\n        }\n        return value;\n    }\n    function normalizeUnitInterval$1(value, label) {\n        if (!Number.isFinite(value) || value < 0 || value > 1) {\n            throw new Error(`${label} must be between 0 and 1.`);\n        }\n    }\n    function identity(size) {\n        return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));\n    }\n    function scale(matrix, factor) {\n        return matrix.map((row) => row.map((value) => value * factor));\n    }\n    function transpose(matrix) {\n        return matrix[0].map((_, column) => matrix.map((row) => row[column]));\n    }\n    function add(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value + right[rowIndex][columnIndex]));\n    }\n    function subtract(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value - right[rowIndex][columnIndex]));\n    }\n    function multiply(left, right) {\n        return left.map((row) => right[0].map((_, column) => row.reduce((sum, value, index) => sum + value * right[index][column], 0)));\n    }\n    function inverse(matrix) {\n        const size = matrix.length;\n        const augmented = matrix.map((row, index) => [\n            ...row,\n            ...identity(size)[index],\n        ]);\n        for (let column = 0; column < size; column += 1) {\n            let pivot = column;\n            for (let row = column + 1; row < size; row += 1) {\n                if (Math.abs(augmented[row][column]) >\n                    Math.abs(augmented[pivot][column])) {\n                    pivot = row;\n                }\n            }\n            if (Math.abs(augmented[pivot][column]) < 1e-12) {\n                throw new Error(\"SORT Kalman covariance is singular.\");\n            }\n            [augmented[column], augmented[pivot]] = [\n                augmented[pivot],\n                augmented[column],\n            ];\n            const divisor = augmented[column][column];\n            augmented[column] = augmented[column].map((value) => value / divisor);\n            for (let row = 0; row < size; row += 1) {\n                if (row === column)\n                    continue;\n                const factor = augmented[row][column];\n                augmented[row] = augmented[row].map((value, index) => value - factor * augmented[column][index]);\n            }\n        }\n        return augmented.map((row) => row.slice(size));\n    }\n\n    /**\n     * Creates one stateful ByteTrack tracker for a single ordered media sequence.\n     *\n     * Defaults and two-stage association mirror roboflow/trackers ByteTrack at\n     * source commit 60b21c8a48676784085fbee455559f16b75a7c9a.\n     * Motion predictions remain internal; only observed detections receive IDs.\n     */\n    function createByteTrackTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.1;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    if ((detection.confidence ?? 1) >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const assignments = new Map();\n                const firstStage = associate(tracks, detections, highDetectionIndexes, minimumIouThreshold);\n                for (const match of firstStage.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                const remainingTracks = firstStage.unmatchedTrackIndexes.map((index) => tracks[index]);\n                const secondStage = associate(remainingTracks, detections, lowDetectionIndexes, minimumIouThreshold);\n                for (const match of secondStage.matches) {\n                    updateMatchedTrack(remainingTracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                // Only unmatched high-confidence observations can start a track.\n                for (const detectionIndex of firstStage.unmatchedDetectionIndexes) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection, true));\n                    }\n                }\n                // Confirmation is sticky once an ID has been allocated. An unmatched\n                // unconfirmed track is discarded immediately, as in Python ByteTrack.\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = assignments.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId;\n                nextTrackerId += 1;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function associate(tracks, detections, detectionIndexes, minimumIouThreshold) {\n        if (tracks.length === 0 || detectionIndexes.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetectionIndexes: [...detectionIndexes],\n                unmatchedTrackIndexes: tracks.map((_, index) => index),\n            };\n        }\n        const scores = tracks.map((track) => {\n            const predictedRect = track.getStateRect();\n            return detectionIndexes.map((detectionIndex) => intersectionOverUnion(predictedRect, detections[detectionIndex].rect));\n        });\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, localDetectionIndex] of maximizeAssignment(scores)) {\n            if (scores[trackIndex][localDetectionIndex] < minimumIouThreshold) {\n                continue;\n            }\n            const detectionIndex = detectionIndexes[localDetectionIndex];\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: detectionIndexes.filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: tracks.flatMap((_, index) => matchedTracks.has(index) ? [] : [index]),\n        };\n    }\n\n    function associateTrackingScores(scores, trackCount, detectionCount, minimumScore, acceptanceScores = scores) {\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of maximizeAssignment(scores)) {\n            if (acceptanceScores[trackIndex][detectionIndex] < minimumScore)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: Array.from({ length: detectionCount }, (_, index) => index).filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: Array.from({ length: trackCount }, (_, index) => index).filter((index) => !matchedTracks.has(index)),\n        };\n    }\n    function pairwiseIou(tracks, detections, bufferRatio = 0) {\n        return tracks.map((track) => detections.map((detection) => bufferedIntersectionOverUnion(track, detection, bufferRatio)));\n    }\n    function bufferedIntersectionOverUnion(left, right, bufferRatio) {\n        const leftWidth = left.width * (1 + 2 * bufferRatio);\n        const leftHeight = left.height * (1 + 2 * bufferRatio);\n        const rightWidth = right.width * (1 + 2 * bufferRatio);\n        const rightHeight = right.height * (1 + 2 * bufferRatio);\n        const leftX = left.x - leftWidth / 2;\n        const leftY = left.y - leftHeight / 2;\n        const rightX = right.x - rightWidth / 2;\n        const rightY = right.y - rightHeight / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + leftWidth, rightX + rightWidth) - Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + leftHeight, rightY + rightHeight) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = leftWidth * leftHeight + rightWidth * rightHeight - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n\n    /**\n     * Kalman state estimator shared by the browser C-BIoU and OC-SORT ports.\n     * Its layouts, covariance update, and gap-scaled constant-velocity model\n     * mirror roboflow/trackers at 60b21c8.\n     */\n    class TrackingKalmanEstimator {\n        representation;\n        dimension;\n        measurementDimension = 4;\n        covariance;\n        measurementNoise = identity(4);\n        processNoise;\n        state;\n        baselineProcessNoise;\n        positionIndexes;\n        velocityIndexes;\n        constructor(initialRect, representation) {\n            this.representation = representation;\n            const measurement = rectToMeasurement(initialRect, representation);\n            this.dimension = representation === \"xcycsr\" ? 7 : 8;\n            this.positionIndexes =\n                representation === \"xcycsr\" ? [0, 1, 2] : [0, 1, 2, 3];\n            this.velocityIndexes =\n                representation === \"xcycsr\" ? [4, 5, 6] : [4, 5, 6, 7];\n            this.state = Array.from({ length: this.dimension }, (_, index) => [\n                measurement[index] ?? 0,\n            ]);\n            this.covariance = identity(this.dimension);\n            this.processNoise = identity(this.dimension);\n            this.baselineProcessNoise = identity(this.dimension);\n        }\n        predict(frameStep, frameRate) {\n            if (this.representation === \"xcycsr\" &&\n                this.state[2][0] + frameStep * this.state[6][0] <= 0) {\n                this.state[6][0] = 0;\n            }\n            const transition = identity(this.dimension);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                transition[positionIndex][this.velocityIndexes[index]] = frameStep;\n            });\n            this.processNoise = this.createProcessNoise(frameStep, frameRate);\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), this.processNoise);\n        }\n        update(rect) {\n            this.updateMeasurement(rectToMeasurement(rect, this.representation));\n        }\n        updateMeasurement(measurement) {\n            const observation = Array.from({ length: 4 }, (_, row) => Array.from({ length: this.dimension }, (_, column) => row === column ? 1 : 0));\n            const measurementColumn = measurement.map((value) => [value]);\n            const innovation = subtract(measurementColumn, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), this.measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(this.dimension), multiply(gain, observation));\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, this.measurementNoise), transpose(gain)));\n        }\n        getRect() {\n            return measurementToRect(this.state.slice(0, 4).map((row) => row[0]), this.representation);\n        }\n        setCovariances(options) {\n            if (options.covariance)\n                this.covariance = clone(options.covariance);\n            if (options.measurementNoise) {\n                this.measurementNoise = clone(options.measurementNoise);\n            }\n            if (options.processNoise) {\n                this.processNoise = clone(options.processNoise);\n                this.baselineProcessNoise = clone(options.processNoise);\n            }\n        }\n        snapshot() {\n            return {\n                covariance: clone(this.covariance),\n                measurementNoise: clone(this.measurementNoise),\n                processNoise: clone(this.processNoise),\n                state: clone(this.state),\n            };\n        }\n        restore(snapshot) {\n            this.covariance = clone(snapshot.covariance);\n            this.measurementNoise = clone(snapshot.measurementNoise);\n            this.processNoise = clone(snapshot.processNoise);\n            this.state = clone(snapshot.state);\n        }\n        createProcessNoise(frameStep, frameRate) {\n            if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n                return clone(this.baselineProcessNoise);\n            }\n            const result = Array.from({ length: this.dimension }, () => new Array(this.dimension).fill(0));\n            const dt2 = frameStep * frameStep;\n            const dt3 = dt2 * frameStep;\n            const dt4 = dt2 * dt2;\n            const kinematicIndexes = new Set([\n                ...this.positionIndexes,\n                ...this.velocityIndexes,\n            ]);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                const velocityIndex = this.velocityIndexes[index];\n                const accelerationVariance = this.baselineProcessNoise[velocityIndex][velocityIndex];\n                result[positionIndex][positionIndex] = (accelerationVariance * dt4) / 4;\n                result[positionIndex][velocityIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][positionIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][velocityIndex] = accelerationVariance * dt2;\n            });\n            for (let index = 0; index < this.dimension; index += 1) {\n                if (!kinematicIndexes.has(index)) {\n                    result[index][index] = this.baselineProcessNoise[index][index];\n                }\n            }\n            return result;\n        }\n    }\n    function rectToMeasurement(rect, representation) {\n        if (representation === \"xcycwh\") {\n            return [rect.x, rect.y, rect.width, rect.height];\n        }\n        return [\n            rect.x,\n            rect.y,\n            rect.width * rect.height,\n            rect.width / (rect.height + 1e-6),\n        ];\n    }\n    function measurementToRect(measurement, representation) {\n        const [x, y, third, fourth] = measurement;\n        if (representation === \"xcycwh\") {\n            return {\n                height: Math.max(1e-3, fourth),\n                width: Math.max(1e-3, third),\n                x,\n                y,\n            };\n        }\n        const width = Math.sqrt(third * fourth);\n        const height = width === 0 ? 0 : third / width;\n        return {\n            height: Math.max(Number.EPSILON, height),\n            width: Math.max(Number.EPSILON, width),\n            x,\n            y,\n        };\n    }\n    function diagonal(values) {\n        return values.map((value, row) => values.map((_, column) => (row === column ? value : 0)));\n    }\n    function scaleMatrix(matrix, factor) {\n        return scale(matrix, factor);\n    }\n    function clone(matrix) {\n        return matrix.map((row) => [...row]);\n    }\n\n    const MINIMUM_DETECTION_CONFIDENCE = 0.1;\n    class CBIoUTrack {\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        estimator;\n        constructor(initial) {\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycwh\");\n            this.setInitialNoise(initial.rect.width, initial.rect.height);\n        }\n        predict(frameStep, frameRate) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                processNoise: this.buildProcessNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.predict(frameStep, frameRate);\n            this.clampState();\n            this.timeSinceUpdate += 1;\n        }\n        update(detection) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                measurementNoise: this.buildMeasurementNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.update(detection.rect);\n            this.clampState();\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        setInitialNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            this.estimator.setCovariances({\n                covariance: diagonal([\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                ]),\n                measurementNoise: this.buildMeasurementNoise(width, height),\n                processNoise: this.buildProcessNoise(width, height),\n            });\n        }\n        buildProcessNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            return diagonal([\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n            ]);\n        }\n        buildMeasurementNoise(width, height) {\n            const sigmaMeasurement = 0.05;\n            return diagonal([\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n            ]);\n        }\n        clampState() {\n            this.estimator.state[2][0] = Math.max(this.estimator.state[2][0], 1e-3);\n            this.estimator.state[3][0] = Math.max(this.estimator.state[3][0], 1e-3);\n        }\n    }\n    /** Creates the detection-only C-BIoU implementation from roboflow/trackers. */\n    function createCBIoUTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ?? 0.2;\n        const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ?? 0.5;\n        const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ?? 0.3;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const instantFirstFrameActivation = options.instantFirstFrameActivation ?? true;\n        const bufferRatioFirst = options.bufferRatioFirst ?? 0.3;\n        const bufferRatioSecond = options.bufferRatioSecond ?? 0.5;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThresholdFirstAssociation, \"minimumIouThresholdFirstAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdSecondAssociation, \"minimumIouThresholdSecondAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdUnconfirmedAssociation, \"minimumIouThresholdUnconfirmedAssociation\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        if (!Number.isFinite(bufferRatioFirst) || bufferRatioFirst < 0) {\n            throw new Error(\"bufferRatioFirst must be a finite non-negative value.\");\n        }\n        if (!Number.isFinite(bufferRatioSecond) || bufferRatioSecond < 0) {\n            throw new Error(\"bufferRatioSecond must be a finite non-negative value.\");\n        }\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let frameId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                frameId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                frameId += 1;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    const confidence = detection.confidence ?? 1;\n                    if (confidence >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else if (confidence > MINIMUM_DETECTION_CONFIDENCE) {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const confirmed = [];\n                const unconfirmed = [];\n                const lost = [];\n                for (const track of tracks) {\n                    if (track.timeSinceUpdate > 1)\n                        lost.push(track);\n                    else if (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        confirmed.push(track);\n                    }\n                    else\n                        unconfirmed.push(track);\n                }\n                const assignments = new Map();\n                const pool = [...confirmed, ...lost];\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const firstScores = pairwiseIou(pool.map((track) => track.getRect()), highDetections.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (highDetections[index].confidence ?? 1)));\n                const firstAssociation = associateTrackingScores(firstScores, pool.length, highDetections.length, minimumIouThresholdFirstAssociation);\n                for (const match of firstAssociation.matches) {\n                    updateMatchedTrack(pool[match.trackIndex], highDetections[match.detectionIndex], assignments);\n                }\n                const remainingTracked = firstAssociation.unmatchedTrackIndexes\n                    .map((index) => pool[index])\n                    .filter((track) => track.timeSinceUpdate === 1);\n                const lowDetections = lowDetectionIndexes.map((index) => detections[index]);\n                const secondScores = pairwiseIou(remainingTracked.map((track) => track.getRect()), lowDetections.map((detection) => detection.rect), bufferRatioSecond);\n                const secondAssociation = associateTrackingScores(secondScores, remainingTracked.length, lowDetections.length, minimumIouThresholdSecondAssociation);\n                for (const match of secondAssociation.matches) {\n                    updateMatchedTrack(remainingTracked[match.trackIndex], lowDetections[match.detectionIndex], assignments);\n                }\n                let unmatchedHighLocal = [...firstAssociation.unmatchedDetectionIndexes];\n                let unmatchedUnconfirmed = unconfirmed.map((_, index) => index);\n                if (unconfirmed.length > 0 && unmatchedHighLocal.length > 0) {\n                    const remainingHigh = unmatchedHighLocal.map((index) => highDetections[index]);\n                    const unconfirmedScores = pairwiseIou(unconfirmed.map((track) => track.getRect()), remainingHigh.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (remainingHigh[index].confidence ?? 1)));\n                    const unconfirmedAssociation = associateTrackingScores(unconfirmedScores, unconfirmed.length, remainingHigh.length, minimumIouThresholdUnconfirmedAssociation);\n                    unmatchedUnconfirmed = unconfirmedAssociation.unmatchedTrackIndexes;\n                    for (const match of unconfirmedAssociation.matches) {\n                        updateMatchedTrack(unconfirmed[match.trackIndex], remainingHigh[match.detectionIndex], assignments);\n                    }\n                    unmatchedHighLocal =\n                        unconfirmedAssociation.unmatchedDetectionIndexes.map((index) => unmatchedHighLocal[index]);\n                }\n                const unmatchedUnconfirmedTracks = new Set(unmatchedUnconfirmed.map((index) => unconfirmed[index]));\n                tracks = tracks.filter((track) => !unmatchedUnconfirmedTracks.has(track));\n                for (const localIndex of unmatchedHighLocal) {\n                    const detection = highDetections[localIndex];\n                    if ((detection.confidence ?? 1) < trackActivationThreshold)\n                        continue;\n                    const track = new CBIoUTrack(detection);\n                    if (frameId === 1 && instantFirstFrameActivation) {\n                        track.trackerId = nextTrackerId++;\n                        assignments.set(detection.detectionIndex, track.trackerId);\n                    }\n                    tracks.push(track);\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.timeSinceUpdate === 0 ||\n                        track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames));\n                return createUpdate(detections, assignments, tracks);\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId++;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function createUpdate(detections, assignments, tracks) {\n        const resolvedAssignments = detections.flatMap((detection) => {\n            const trackerId = assignments.get(detection.detectionIndex);\n            return trackerId === undefined\n                ? []\n                : [{ detectionIndex: detection.detectionIndex, trackerId }];\n        });\n        return {\n            activeTrackCount: tracks.length,\n            assignments: resolvedAssignments,\n            confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined)\n                .length,\n        };\n    }\n\n    class OCSortTrack {\n        deltaT;\n        age = 0;\n        lastObservation;\n        trackerId;\n        successfulConsecutiveUpdates = 0;\n        timeSinceUpdate = 0;\n        velocity;\n        frozenState;\n        observed = true;\n        observations = new Map();\n        estimator;\n        constructor(initial, deltaT) {\n            this.deltaT = deltaT;\n            this.lastObservation = initial;\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycsr\");\n            this.configureNoise();\n        }\n        predict(frameStep, frameRate) {\n            if (this.observed && this.timeSinceUpdate > 0) {\n                this.frozenState = this.estimator.snapshot();\n                this.observed = false;\n            }\n            this.estimator.predict(frameStep, frameRate);\n            if (this.timeSinceUpdate > 0) {\n                this.successfulConsecutiveUpdates = 0;\n            }\n            this.timeSinceUpdate += 1;\n            this.age += 1;\n        }\n        update(detection, frameStep, frameRate) {\n            const previous = this.getPreviousObservation();\n            if (previous) {\n                this.velocity = computeVelocity(previous, detection);\n            }\n            if (!this.observed && this.frozenState) {\n                this.unfreeze(detection, frameStep, frameRate);\n            }\n            this.estimator.update(detection.rect);\n            this.observed = true;\n            this.timeSinceUpdate = 0;\n            this.successfulConsecutiveUpdates += 1;\n            this.lastObservation = detection;\n            this.observations.set(this.age, detection);\n            const cutoff = this.age - this.deltaT;\n            for (const age of this.observations.keys()) {\n                if (age < cutoff)\n                    this.observations.delete(age);\n            }\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        getPreviousObservation() {\n            if (this.observations.size === 0)\n                return undefined;\n            for (let index = 0; index < this.deltaT; index += 1) {\n                const delta = this.deltaT - index;\n                const observation = this.observations.get(this.age - delta);\n                if (observation)\n                    return observation;\n            }\n            const latestAge = Math.max(...this.observations.keys());\n            return this.observations.get(latestAge);\n        }\n        configureNoise() {\n            const measurementNoise = identity(4);\n            for (let index = 2; index < 4; index += 1) {\n                measurementNoise[index][index] *= 10;\n            }\n            const covariance = scaleMatrix(identity(7), 10);\n            for (let index = 4; index < 7; index += 1) {\n                covariance[index][index] *= 1000;\n            }\n            const processNoise = identity(7);\n            processNoise[6][6] *= 0.01;\n            for (let index = 4; index < 7; index += 1) {\n                processNoise[index][index] *= 0.01;\n            }\n            this.estimator.setCovariances({\n                covariance,\n                measurementNoise,\n                processNoise,\n            });\n        }\n        unfreeze(detection, frameStep, frameRate) {\n            if (!this.frozenState || this.timeSinceUpdate === 0)\n                return;\n            this.estimator.restore(this.frozenState);\n            const timeGap = this.timeSinceUpdate;\n            const start = rectToMeasurement(this.lastObservation.rect, \"xcycsr\");\n            const end = rectToMeasurement(detection.rect, \"xcycsr\");\n            const startWidth = Math.sqrt(start[2] * start[3]);\n            const startHeight = start[3] === 0 ? 0 : Math.sqrt(start[2] / start[3]);\n            const endWidth = Math.sqrt(end[2] * end[3]);\n            const endHeight = end[3] === 0 ? 0 : Math.sqrt(end[2] / end[3]);\n            for (let index = 0; index < timeGap; index += 1) {\n                const progress = (index + 1) / timeGap;\n                const x = start[0] + progress * (end[0] - start[0]);\n                const y = start[1] + progress * (end[1] - start[1]);\n                const width = startWidth + progress * (endWidth - startWidth);\n                const height = startHeight + progress * (endHeight - startHeight);\n                this.estimator.updateMeasurement([x, y, width * height, width / height]);\n                if (index < timeGap - 1) {\n                    this.estimator.predict(frameStep, frameRate);\n                }\n            }\n            this.frozenState = undefined;\n        }\n    }\n    /** Creates the observation-centric SORT implementation from roboflow/trackers. */\n    function createOCSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        const directionConsistencyWeight = options.directionConsistencyWeight ?? 0.2;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const deltaT = normalizePositiveInteger$1(options.deltaT ?? 3, \"deltaT\");\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(directionConsistencyWeight, \"directionConsistencyWeight\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let frameCount = 0;\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                frameCount = 0;\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                // Match roboflow/trackers: an empty stream before any track exists is\n                // not part of OC-SORT's early-sequence activation window.\n                if (tracks.length === 0 && detections.length === 0) {\n                    return {\n                        activeTrackCount: 0,\n                        assignments: [],\n                        confirmedTrackCount: 0,\n                    };\n                }\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = detections.flatMap((detection, index) => detection.confidence === undefined ||\n                    detection.confidence >= highConfidenceDetectionThreshold\n                    ? [index]\n                    : []);\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const iouScores = pairwiseIou(tracks.map((track) => track.getRect()), highDetections.map((detection) => detection.rect));\n                const combinedScores = iouScores.map((row, trackIndex) => row.map((iou, detectionIndex) => {\n                    if (directionConsistencyWeight === 0)\n                        return iou;\n                    return (iou +\n                        directionConsistencyWeight *\n                            directionConsistency(tracks[trackIndex], highDetections[detectionIndex]) *\n                            (highDetections[detectionIndex].confidence ?? 1));\n                }));\n                const primary = associateTrackingScores(combinedScores, tracks.length, highDetections.length, minimumIouThreshold, iouScores);\n                const assignments = new Map();\n                for (const match of primary.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], highDetections[match.detectionIndex], assignments, frameStep);\n                }\n                let remainingHigh = [...primary.unmatchedDetectionIndexes];\n                if (primary.unmatchedTrackIndexes.length > 0 &&\n                    remainingHigh.length > 0) {\n                    const unmatchedTracks = primary.unmatchedTrackIndexes.map((index) => tracks[index]);\n                    const unmatchedDetections = remainingHigh.map((index) => highDetections[index]);\n                    const recoveryScores = pairwiseIou(unmatchedTracks.map((track) => track.lastObservation.rect), unmatchedDetections.map((detection) => detection.rect));\n                    const recovery = associateTrackingScores(recoveryScores, unmatchedTracks.length, unmatchedDetections.length, minimumIouThreshold);\n                    for (const match of recovery.matches) {\n                        updateMatchedTrack(unmatchedTracks[match.trackIndex], unmatchedDetections[match.detectionIndex], assignments, frameStep);\n                    }\n                    remainingHigh = recovery.unmatchedDetectionIndexes.map((index) => remainingHigh[index]);\n                }\n                for (const localIndex of remainingHigh) {\n                    tracks.push(new OCSortTrack(highDetections[localIndex], deltaT));\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate);\n                frameCount += 1;\n                const resolvedAssignments = detections.flatMap((detection) => {\n                    const trackerId = assignments.get(detection.detectionIndex);\n                    return trackerId === undefined\n                        ? []\n                        : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                });\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: resolvedAssignments,\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments, frameStep) {\n            track.update(detection, frameStep, frameRate);\n            const earlySequence = frameCount <= minimumConsecutiveFrames;\n            const shouldEmit = (earlySequence && track.timeSinceUpdate === 0) ||\n                track.successfulConsecutiveUpdates >= minimumConsecutiveFrames;\n            if (shouldEmit) {\n                if (track.trackerId === undefined) {\n                    track.trackerId = nextTrackerId++;\n                }\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function computeVelocity(previous, current) {\n        const deltaX = current.rect.x - previous.rect.x;\n        const deltaY = current.rect.y - previous.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        return { x: deltaX / norm, y: deltaY / norm };\n    }\n    function directionConsistency(track, detection) {\n        if (!track.velocity)\n            return 0;\n        const reference = track.getPreviousObservation() ?? track.lastObservation;\n        const deltaX = detection.rect.x - reference.rect.x;\n        const deltaY = detection.rect.y - reference.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        const cosine = Math.max(-1, Math.min(1, track.velocity.x * (deltaX / norm) + track.velocity.y * (deltaY / norm)));\n        const angle = Math.acos(cosine);\n        return (Math.PI / 2 - Math.abs(angle)) / Math.PI;\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createSortTracker(options = {}) {\n        return createSortTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createByteTrackTracker(options = {}) {\n        return createByteTrackTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createCBIoUTracker(options = {}) {\n        return createCBIoUTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createOCSortTracker(options = {}) {\n        return createOCSortTracker$1(options);\n    }\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"OrientedBox\"] = \"orientedBox\";\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 PercentageBarPlacement;\n    (function (PercentageBarPlacement) {\n        PercentageBarPlacement[\"Top\"] = \"top\";\n        PercentageBarPlacement[\"Bottom\"] = \"bottom\";\n        PercentageBarPlacement[\"InsideTop\"] = \"insideTop\";\n        PercentageBarPlacement[\"InsideBottom\"] = \"insideBottom\";\n    })(PercentageBarPlacement || (PercentageBarPlacement = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read, or was refused before any read. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, and a gate that stops one has to bound its own wait\n     * or a producer nothing answers for never runs again.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        /**\n         * The picture is waiting on media the source has not handed over yet, which\n         * is the bytes and their decode rather than anything downstream of them.\n         * `PlaybackBuffering` is what a transport reports once it has already\n         * stopped; this is reported from the read itself, including the reads a seek\n         * makes while the transport still reads as paused.\n         */\n        MediaSessionActivityKind[\"MediaSourceReading\"] = \"mediaSourceReading\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        /**\n         * The render-preparation gate held the picture for artifacts that never\n         * arrived and let it go. Nothing is blocked: the frames reaching the screen\n         * are the ones whose artifacts were given up on. What is waited on is\n         * preparation finishing another frame, which is what lets the gate hold the\n         * picture again; `RenderPreparing` covers the holds that are running.\n         */\n        MediaSessionActivityKind[\"RenderPreparationAbandoned\"] = \"renderPreparationAbandoned\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    let tracker;\n    self.addEventListener(\"message\", (event) => {\n        const request = event.data;\n        try {\n            let response;\n            if (request.type === \"configure\") {\n                switch (request.processor.algorithm) {\n                    case \"bytetrack\":\n                        tracker = createByteTrackTracker(request.processor.options);\n                        break;\n                    case \"cbiou\":\n                        tracker = createCBIoUTracker(request.processor.options);\n                        break;\n                    case \"ocsort\":\n                        tracker = createOCSortTracker(request.processor.options);\n                        break;\n                    default:\n                        tracker = createSortTracker(request.processor.options);\n                }\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else if (request.type === \"reset\") {\n                tracker?.reset();\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else {\n                if (!tracker) {\n                    throw new Error(\"Tracking worker is not configured.\");\n                }\n                const startedAt = performance.now();\n                const update = tracker.update(request.detections, request.frameIndex);\n                response = {\n                    ...update,\n                    durationMs: performance.now() - startedAt,\n                    requestId: request.requestId,\n                    type: \"success\",\n                };\n            }\n            self.postMessage(response);\n        }\n        catch (error) {\n            self.postMessage({\n                message: error instanceof Error ? error.message : \"Tracking worker failed.\",\n                requestId: request.requestId,\n                type: \"error\",\n            });\n        }\n    });\n\n})();";
 
 const DEFAULT_WORKER_NAME$1 = "supervision-detection-post-processing";
 let defaultWorkerUrl$1;
@@ -3965,6 +3965,8 @@ async function createMediaRendererCore(options, providers) {
         maskHaloStyle: options.maskHaloStyle,
         maskStyle: options.maskStyle,
         markerStyle: options.markerStyle,
+        orientedBoxStyle: options.orientedBoxStyle,
+        percentageBarStyle: options.percentageBarStyle,
         polygonStyle: options.polygonStyle,
         polylineStyle: options.polylineStyle,
         renderers: options.renderers,
@@ -4733,7 +4735,9 @@ async function createMediaRendererCore(options, providers) {
             maskHaloStyle: currentPresentation.maskHaloStyle,
             maskStyle: currentPresentation.maskStyle,
             markerStyle: currentPresentation.markerStyle,
+            percentageBarStyle: currentPresentation.percentageBarStyle,
             maxDevicePixelRatio: options.maxDevicePixelRatio,
+            orientedBoxStyle: currentPresentation.orientedBoxStyle,
             onPresentationUpdate(presentedSample) {
                 if (!runtimeState.isDestroyed()) {
                     runtimeState.recordPresentationUpdate(presentedSample);
@@ -5448,7 +5452,7 @@ function writePixel(rgba, canvasWidth, x, y, color) {
     rgba[rgbaOffset + 3] = color.alpha;
 }
 
-const EMBEDDED_MASK_PREPARATION_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n    function decodeCompressedRleMask(mask) {\n        if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {\n            throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);\n        }\n        const data = new Uint8Array(mask.width * mask.height);\n        const counts = decodeCompressedRleCounts(mask.counts);\n        let offset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            const isForeground = index % 2 === 1;\n            if (isForeground) {\n                for (let runOffset = 0; runOffset < runLength; runOffset += 1) {\n                    const maskOffset = offset + runOffset;\n                    const x = Math.floor(maskOffset / mask.height);\n                    const y = maskOffset % mask.height;\n                    const rowMajorOffset = y * mask.width + x;\n                    if (rowMajorOffset < data.length) {\n                        data[rowMajorOffset] = 1;\n                    }\n                }\n            }\n            offset += runLength;\n        }\n        return {\n            data,\n            height: mask.height,\n            width: mask.width,\n        };\n    }\n    function decodeCompressedRleCounts(counts) {\n        const decoded = [];\n        let index = 0;\n        while (index < counts.length) {\n            let value = 0;\n            let shift = 0;\n            let charCode;\n            do {\n                charCode = counts.charCodeAt(index) - 48;\n                index += 1;\n                value |= (charCode & 0x1f) << shift;\n                shift += 5;\n            } while (charCode & 0x20);\n            if (charCode & 0x10) {\n                value |= -1 << shift;\n            }\n            if (decoded.length > 2) {\n                value += decoded[decoded.length - 2] ?? 0;\n            }\n            decoded.push(value);\n        }\n        return decoded;\n    }\n    function encodeCompressedRleCounts(counts) {\n        return counts\n            .map((count, index) => {\n            let value = index > 2 ? count - counts[index - 2] : count;\n            let encoded = \"\";\n            let more = true;\n            while (more) {\n                let charCode = value & 0x1f;\n                value >>= 5;\n                more = !((value === 0 && (charCode & 0x10) === 0) ||\n                    (value === -1 && (charCode & 0x10) !== 0));\n                if (more) {\n                    charCode |= 0x20;\n                }\n                encoded += String.fromCharCode(charCode + 48);\n            }\n            return encoded;\n        })\n            .join(\"\");\n    }\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n    function encodeBinaryMask(data, width, height) {\n        assertMaskDimensions(data, width, height);\n        const runs = [];\n        let currentValue = 0;\n        let runLength = 0;\n        for (let x = 0; x < width; x += 1) {\n            for (let y = 0; y < height; y += 1) {\n                const value = data[y * width + x] ? 1 : 0;\n                if (value === currentValue) {\n                    runLength += 1;\n                }\n                else {\n                    runs.push(runLength);\n                    currentValue = value;\n                    runLength = 1;\n                }\n            }\n        }\n        runs.push(runLength);\n        return {\n            counts: encodeCompressedRleCounts(runs),\n            encoding: DetectionMaskEncoding.CompressedRle,\n            height,\n            width,\n        };\n    }\n    function assertMaskSize(width, height) {\n        if (!Number.isInteger(width) || width <= 0) {\n            throw new Error(\"Mask width must be a positive integer.\");\n        }\n        if (!Number.isInteger(height) || height <= 0) {\n            throw new Error(\"Mask height must be a positive integer.\");\n        }\n    }\n    function assertMaskDimensions(data, width, height) {\n        assertMaskSize(width, height);\n        if (data.length !== width * height) {\n            throw new Error(\"Mask data length must equal width * height.\");\n        }\n    }\n\n    function centerRectToTopLeftRect(rect) {\n        return {\n            height: rect.height,\n            width: rect.width,\n            x: rect.x - rect.width / 2,\n            y: rect.y - rect.height / 2,\n        };\n    }\n    function getPointsRect(points) {\n        if (points.length === 0) {\n            return undefined;\n        }\n        let minX = Number.POSITIVE_INFINITY;\n        let minY = Number.POSITIVE_INFINITY;\n        let maxX = Number.NEGATIVE_INFINITY;\n        let maxY = Number.NEGATIVE_INFINITY;\n        for (const point of points) {\n            minX = Math.min(minX, point.x);\n            minY = Math.min(minY, point.y);\n            maxX = Math.max(maxX, point.x);\n            maxY = Math.max(maxY, point.y);\n        }\n        return {\n            height: maxY - minY,\n            width: maxX - minX,\n            x: (minX + maxX) / 2,\n            y: (minY + maxY) / 2,\n        };\n    }\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n    function rasterizePolygonToMask(points, dimensions) {\n        const data = createEmptyMask(dimensions);\n        if (points.length < 3) {\n            return data;\n        }\n        const bounds = centerRectToTopLeftRect(getPointsRect(points));\n        const startY = Math.max(0, Math.floor(bounds.y));\n        const endY = Math.min(dimensions.height - 1, Math.ceil(bounds.y + bounds.height));\n        for (let y = startY; y <= endY; y += 1) {\n            const scanY = y + 0.5;\n            const intersections = [];\n            for (let index = 0; index < points.length; index += 1) {\n                const current = points[index];\n                const next = points[(index + 1) % points.length];\n                if ((current.y <= scanY && next.y > scanY) ||\n                    (next.y <= scanY && current.y > scanY)) {\n                    const ratio = (scanY - current.y) / (next.y - current.y);\n                    intersections.push(current.x + ratio * (next.x - current.x));\n                }\n            }\n            intersections.sort((left, right) => left - right);\n            for (let index = 0; index < intersections.length - 1; index += 2) {\n                const left = Math.max(0, Math.round(intersections[index]));\n                const right = Math.min(dimensions.width, Math.round(intersections[index + 1]));\n                for (let x = left; x < right; x += 1) {\n                    data[y * dimensions.width + x] = 1;\n                }\n            }\n        }\n        return data;\n    }\n    function createEmptyMask(dimensions) {\n        if (!Number.isInteger(dimensions.width) ||\n            dimensions.width <= 0 ||\n            !Number.isInteger(dimensions.height) ||\n            dimensions.height <= 0) {\n            throw new Error(\"Media dimensions must be positive integers.\");\n        }\n        return new Uint8Array(dimensions.width * dimensions.height);\n    }\n\n    /**\n     * Palette slots an id raster can name, one of them the background. A GLSL\n     * fragment stage is guaranteed only 224 uniform vectors, and a palette entry\n     * costs 2.25 of them, so this stays a multiple of four and well inside that\n     * budget; past it a frame draws from the RGBA composite instead.\n     */\n    const MAX_ID_MASK_PALETTE_ENTRIES = 80;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions, options = {}) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const maskWidth = Math.max(...instructions.map(({ mask }) => mask.width));\n        const maskHeight = Math.max(...instructions.map(({ mask }) => mask.height));\n        const width = resolveRasterWidth(maskWidth, options.maxWidth);\n        const height = width === maskWidth\n            ? maskHeight\n            : Math.max(1, Math.round((width * maskHeight) / maskWidth));\n        const scaledAxes = width === maskWidth\n            ? undefined\n            : createScaledMaskAxes({ height, maskHeight, maskWidth, width });\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        const fillPalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokePalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokeWidths = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4));\n        let hasStroke = false;\n        let maxStrokeWidth = 0;\n        for (const instruction of instructions) {\n            const detectionMaskId = resolveIdMaskPaletteId(instruction.detectionIndex);\n            if (detectionMaskId === undefined) {\n                return undefined;\n            }\n            writeIdMaskPaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);\n            if (instruction.stroke && instruction.stroke.width > 0) {\n                const strokeWidth = resolveIdMaskStrokeTexels(instruction.stroke.width, maskWidth, width);\n                hasStroke = true;\n                strokeWidths[detectionMaskId] = strokeWidth;\n                maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);\n                writeIdMaskPaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);\n            }\n            if (scaledAxes) {\n                writeScaledMaskRuns(data, scaledAxes, instruction.mask, detectionMaskId);\n            }\n            else {\n                writeMaskRuns(data, width, instruction.mask, detectionMaskId);\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            sourceWidth: maskWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\n    }\n    /**\n     * Compressed RLE counts runs down each column in turn, so a foreground run is\n     * a contiguous walk down one column that wraps into the next.\n     */\n    function writeMaskRuns(data, frameWidth, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let frameOffset = y * frameWidth + x;\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[frameOffset] = detectionMaskId;\n                y += 1;\n                frameOffset += frameWidth;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    frameOffset = x;\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    /**\n     * The scaled twin of writeMaskRuns. Every source pixel marks the texel it lands\n     * in, so a mask keeps every part of itself the smaller raster can hold and\n     * gains up to a texel at its edges.\n     */\n    function writeScaledMaskRuns(data, axes, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let column = axes.columns[x];\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[axes.rows[y] + column] = detectionMaskId;\n                y += 1;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    column = axes.columns[x];\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    function resolveRasterWidth(maskWidth, maxWidth) {\n        return maxWidth !== undefined && maxWidth > 0 && maxWidth < maskWidth\n            ? Math.max(1, Math.floor(maxWidth))\n            : maskWidth;\n    }\n    /**\n     * A stroke is measured in texels of the raster it is drawn on, so a coarser\n     * raster measures it in coarser texels. A stroke of a texel or more keeps at\n     * least one, the thinnest line the shader can draw; a narrower one keeps its\n     * own width, which the shader draws as an inner boundary at any scale. The\n     * ceiling is the widest neighbourhood the shaders scan, so a wider stroke would\n     * be drawn at the ceiling anyway and every layer drawing the same annotation\n     * has to arrive at the same width.\n     */\n    function resolveIdMaskStrokeTexels(strokeWidth, maskWidth, rasterWidth) {\n        const scale = maskWidth > 0 ? rasterWidth / maskWidth : 1;\n        return Math.min(Math.max(strokeWidth * scale, Math.min(strokeWidth, 1)), MAX_ID_MASK_STROKE_WIDTH);\n    }\n    function createScaledMaskAxes(frame) {\n        return {\n            columns: createMaskAxisMap(frame.maskWidth, frame.width, 1),\n            rows: createMaskAxisMap(frame.maskHeight, frame.height, frame.width),\n        };\n    }\n    /** Rows hold their destination offset, so writing a run is two lookups. */\n    function createMaskAxisMap(sourceLength, targetLength, stride) {\n        const map = new Int32Array(sourceLength);\n        const scale = targetLength / sourceLength;\n        for (let index = 0; index < sourceLength; index += 1) {\n            map[index] = Math.min(targetLength - 1, Math.floor(index * scale)) * stride;\n        }\n        return map;\n    }\n    /**\n     * The palette slot a detection index names, or undefined when the palette has\n     * no slot for it. Slot zero is the background, so the ids start at one and the\n     * last detection the palette can name sits one index below the last slot.\n     */\n    function resolveIdMaskPaletteId(detectionIndex) {\n        const detectionMaskId = detectionIndex + 1;\n        return detectionMaskId > 0 && detectionMaskId < MAX_ID_MASK_PALETTE_ENTRIES\n            ? detectionMaskId\n            : undefined;\n    }\n    function writeIdMaskPaletteEntry(palette, detectionMaskId, color, alpha) {\n        const offset = detectionMaskId * 4;\n        palette[offset] = ((color >> 16) & 0xff) / 255;\n        palette[offset + 1] = ((color >> 8) & 0xff) / 255;\n        palette[offset + 2] = (color & 0xff) / 255;\n        palette[offset + 3] = Math.max(0, Math.min(alpha, 1));\n    }\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read, or was refused before any read. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, and a gate that stops one has to bound its own wait\n     * or a producer nothing answers for never runs again.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        /**\n         * The picture is waiting on media the source has not handed over yet, which\n         * is the bytes and their decode rather than anything downstream of them.\n         * `PlaybackBuffering` is what a transport reports once it has already\n         * stopped; this is reported from the read itself, including the reads a seek\n         * makes while the transport still reads as paused.\n         */\n        MediaSessionActivityKind[\"MediaSourceReading\"] = \"mediaSourceReading\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        /**\n         * The render-preparation gate held the picture for artifacts that never\n         * arrived and let it go. Nothing is blocked: the frames reaching the screen\n         * are the ones whose artifacts were given up on. What is waited on is\n         * preparation finishing another frame, which is what lets the gate hold the\n         * picture again; `RenderPreparing` covers the holds that are running.\n         */\n        MediaSessionActivityKind[\"RenderPreparationAbandoned\"] = \"renderPreparationAbandoned\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    /** Builds compact, independent alpha crops so overlapping masks stay exact. */\n    function createRegionMaskCoverageFrame(instructions) {\n        const entries = [];\n        for (const instruction of instructions) {\n            if (!instruction.regionCoverageMask) {\n                continue;\n            }\n            const entry = cropCoverageMask(instruction.detectionIndex, decodeCompressedRleMask(instruction.regionCoverageMask));\n            if (entry) {\n                entries.push(entry);\n            }\n        }\n        return entries.length > 0 ? { entries } : undefined;\n    }\n    function cropCoverageMask(detectionIndex, decodedMask) {\n        let minX = decodedMask.width;\n        let minY = decodedMask.height;\n        let maxX = -1;\n        let maxY = -1;\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                minX = Math.min(minX, x);\n                minY = Math.min(minY, y);\n                maxX = Math.max(maxX, x);\n                maxY = Math.max(maxY, y);\n            }\n        }\n        if (maxX < minX || maxY < minY) {\n            return undefined;\n        }\n        const width = maxX - minX + 1;\n        const height = maxY - minY + 1;\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        for (let y = minY; y <= maxY; y += 1) {\n            for (let x = minX; x <= maxX; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                data[(y - minY) * width + (x - minX)] = 255;\n            }\n        }\n        return { data, detectionIndex, height, width, x: minX, y: minY };\n    }\n    function compositeMaskFrame(instructions) {\n        const maskInstructions = materializeMaskInstructions(instructions);\n        if (maskInstructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...maskInstructions.map(({ mask }) => mask.width));\n        const height = Math.max(...maskInstructions.map(({ mask }) => mask.height));\n        const data = new Uint8ClampedArray(new ArrayBuffer(width * height * 4));\n        for (const instruction of maskInstructions) {\n            compositeInstruction(data, width, instruction);\n        }\n        return { data, height, width };\n    }\n    function createIdMaskRasterFrame(instructions, maxRasterWidth) {\n        try {\n            return createIdMaskFrame(materializeMaskInstructions(instructions), {\n                maxWidth: maxRasterWidth,\n            });\n        }\n        catch {\n            // The id raster is the fast path, not the only one: answering with nothing\n            // puts the caller on the RGBA composite, which draws the same picture.\n            return undefined;\n        }\n    }\n    /**\n     * Whether the palette has a slot for every detection this frame masks. An id\n     * names a detection by its index in the frame, so one masked detection past the\n     * last slot leaves the whole frame without an id raster however few masks it\n     * carries.\n     */\n    function canIdMaskPaletteNameFrame(instructions) {\n        return instructions.every((instruction) => instruction.visible === false ||\n            resolveIdMaskPaletteId(instruction.detectionIndex) !== undefined);\n    }\n    function createIdMaskPlane(instructions, maxRasterWidth) {\n        // The plane carries the ids a failed cook could not. A frame the palette\n        // cannot name has none to carry, and cooking it again reaches the same\n        // refusal after rasterizing every mask a second time.\n        if (!canIdMaskPaletteNameFrame(instructions)) {\n            return undefined;\n        }\n        const frame = createIdMaskRasterFrame(instructions, maxRasterWidth);\n        return frame\n            ? { data: frame.data, height: frame.height, width: frame.width }\n            : undefined;\n    }\n    function compositeInstruction(rgba, canvasWidth, instruction) {\n        const fill = resolveRgbaColor(instruction.color, instruction.alpha);\n        const bounds = compositeMaskFill(rgba, canvasWidth, instruction.mask, fill);\n        if (instruction.stroke && bounds) {\n            compositeMaskStroke(rgba, canvasWidth, decodeCompressedRleMask(instruction.mask), bounds, instruction.stroke);\n        }\n    }\n    function materializeMaskInstructions(instructions) {\n        return instructions\n            .filter((instruction) => instruction.visible !== false)\n            .map((instruction) => {\n            if (instruction.mask) {\n                return instruction;\n            }\n            const { height, points, width } = instruction.polygon;\n            return {\n                alpha: instruction.alpha,\n                color: instruction.color,\n                detectionIndex: instruction.detectionIndex,\n                mask: encodeBinaryMask(rasterizePolygonToMask(points, { height, width }), width, height),\n                stroke: instruction.stroke,\n            };\n        });\n    }\n    /**\n     * Compressed RLE counts runs down each column in turn, so a foreground run is\n     * a contiguous walk down one column that wraps into the next.\n     */\n    function compositeMaskFill(rgba, canvasWidth, mask, fill) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        const maskArea = maskWidth * maskHeight;\n        let maskOffset = 0;\n        let minX = maskWidth;\n        let minY = maskHeight;\n        let maxX = -1;\n        let maxY = -1;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let columnX = Math.floor(maskOffset / maskHeight);\n            let columnY = maskOffset - columnX * maskHeight;\n            for (let step = 0; step < runLength; step += 1) {\n                // A run can outlast the columns the mask has; the pixel it then names\n                // is wherever that column-major offset lands when read back row-major.\n                const rowMajorOffset = columnY * maskWidth + columnX;\n                if (rowMajorOffset < maskArea) {\n                    const x = rowMajorOffset % maskWidth;\n                    const y = (rowMajorOffset - x) / maskWidth;\n                    writePixel(rgba, canvasWidth, x, y, fill);\n                    minX = Math.min(minX, x);\n                    minY = Math.min(minY, y);\n                    maxX = Math.max(maxX, x);\n                    maxY = Math.max(maxY, y);\n                }\n                columnY += 1;\n                if (columnY === maskHeight) {\n                    columnY = 0;\n                    columnX += 1;\n                }\n            }\n            maskOffset += runLength;\n        }\n        return maxX < minX || maxY < minY ? undefined : { maxX, maxY, minX, minY };\n    }\n    function compositeMaskStroke(rgba, canvasWidth, decodedMask, bounds, stroke) {\n        const width = Math.round(stroke.width);\n        if (width <= 0) {\n            return;\n        }\n        const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);\n        for (let y = bounds.minY; y <= bounds.maxY; y += 1) {\n            for (let x = bounds.minX; x <= bounds.maxX; x += 1) {\n                if (!isMaskPixel(decodedMask, x, y) ||\n                    !isBoundaryPixel(decodedMask, x, y)) {\n                    continue;\n                }\n                for (let offsetY = -width; offsetY <= width; offsetY += 1) {\n                    for (let offsetX = -width; offsetX <= width; offsetX += 1) {\n                        const strokeX = x + offsetX;\n                        const strokeY = y + offsetY;\n                        if (isOutsideMaskBounds(decodedMask, strokeX, strokeY) ||\n                            isMaskPixel(decodedMask, strokeX, strokeY)) {\n                            continue;\n                        }\n                        writePixel(rgba, canvasWidth, strokeX, strokeY, strokeColor);\n                    }\n                }\n            }\n        }\n    }\n    function isBoundaryPixel(mask, x, y) {\n        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {\n            for (let offsetX = -1; offsetX <= 1; offsetX += 1) {\n                if (offsetX === 0 && offsetY === 0) {\n                    continue;\n                }\n                const neighborX = x + offsetX;\n                const neighborY = y + offsetY;\n                if (isOutsideMaskBounds(mask, neighborX, neighborY) ||\n                    !isMaskPixel(mask, neighborX, neighborY)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    function isMaskPixel(mask, x, y) {\n        return mask.data[y * mask.width + x] === 1;\n    }\n    function isOutsideMaskBounds(mask, x, y) {\n        return x < 0 || y < 0 || x >= mask.width || y >= mask.height;\n    }\n    function resolveRgbaColor(color, alpha) {\n        return {\n            alpha: Math.round(Math.max(0, Math.min(alpha, 1)) * 255),\n            blue: color & 0xff,\n            green: (color >> 8) & 0xff,\n            red: (color >> 16) & 0xff,\n        };\n    }\n    function writePixel(rgba, canvasWidth, x, y, color) {\n        const rgbaOffset = (y * canvasWidth + x) * 4;\n        rgba[rgbaOffset] = color.red;\n        rgba[rgbaOffset + 1] = color.green;\n        rgba[rgbaOffset + 2] = color.blue;\n        rgba[rgbaOffset + 3] = color.alpha;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"IdMask\"] = \"idMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\n    /**\n     * How an id raster is laid out for the texture it is uploaded into. WebGPU\n     * takes any bytesPerRow, so ids go up one byte per pixel. WebGL aligns every\n     * uploaded row to four bytes and rejects a single-channel upload whose width\n     * is not a multiple of four, which is what the four-channel layout is for.\n     */\n    var IdMaskTextureFormat;\n    (function (IdMaskTextureFormat) {\n        IdMaskTextureFormat[\"R8\"] = \"r8unorm\";\n        IdMaskTextureFormat[\"Rgba8\"] = \"rgba8unorm\";\n    })(IdMaskTextureFormat || (IdMaskTextureFormat = {}));\n\n    var MaskPreparationWorkerMessageType;\n    (function (MaskPreparationWorkerMessageType) {\n        MaskPreparationWorkerMessageType[\"Complete\"] = \"complete\";\n        MaskPreparationWorkerMessageType[\"Empty\"] = \"empty\";\n        MaskPreparationWorkerMessageType[\"Error\"] = \"error\";\n        MaskPreparationWorkerMessageType[\"Prepare\"] = \"prepare\";\n    })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));\n\n    const workerScope = globalThis;\n    workerScope.addEventListener(\"message\", (event) => {\n        const message = event.data;\n        if (message.type !== MaskPreparationWorkerMessageType.Prepare) {\n            return;\n        }\n        prepareMaskFrame(message);\n    });\n    function prepareMaskFrame(message) {\n        try {\n            const regionMaskCoverage = createRegionMaskCoverageFrame(message.job.instructions);\n            const coverageTransfers = getRegionMaskCoverageTransfers(regionMaskCoverage);\n            const idMaskFrame = createIdMaskRasterFrame(message.job.instructions, message.job.maxRasterWidth);\n            if (idMaskFrame) {\n                workerScope.postMessage({\n                    artifactKind: PreparedMaskFrameKind.IdMask,\n                    fillPalette: idMaskFrame.fillPalette,\n                    hasStroke: idMaskFrame.hasStroke,\n                    height: idMaskFrame.height,\n                    key: message.job.key,\n                    maxStrokeWidth: idMaskFrame.maxStrokeWidth,\n                    raster: idMaskFrame.data,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    sourceWidth: idMaskFrame.sourceWidth,\n                    strokePalette: idMaskFrame.strokePalette,\n                    strokeWidths: idMaskFrame.strokeWidths,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                    width: idMaskFrame.width,\n                }, [\n                    idMaskFrame.data.buffer,\n                    idMaskFrame.fillPalette.buffer,\n                    idMaskFrame.strokePalette.buffer,\n                    idMaskFrame.strokeWidths.buffer,\n                    ...coverageTransfers,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame && !regionMaskCoverage) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const preparedPixels = compositedFrame ?? createTransparentCoverageCarrier();\n            const imageData = new ImageData(preparedPixels.data, preparedPixels.width, preparedPixels.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            const idMaskPlane = createIdMaskPlane(message.job.instructions, message.job.maxRasterWidth);\n            const idMaskTransfers = idMaskPlane ? [idMaskPlane.data.buffer] : [];\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    idMaskPlane,\n                    imageBitmap,\n                    key: message.job.key,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [imageBitmap, ...idMaskTransfers, ...coverageTransfers]);\n                return;\n            }\n            workerScope.postMessage({\n                idMaskPlane,\n                imageData,\n                key: message.job.key,\n                regionMaskCoverage,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [imageData.data.buffer, ...idMaskTransfers, ...coverageTransfers]);\n        }\n        catch (error) {\n            workerScope.postMessage({\n                error: error instanceof Error\n                    ? error.message\n                    : \"Unable to prepare mask frame.\",\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Error,\n            });\n        }\n    }\n    /**\n     * A frame that carries only region coverage has nothing to composite, and the\n     * RGBA branch still has to produce an artifact for the coverage to ride on.\n     */\n    function createTransparentCoverageCarrier() {\n        return {\n            data: new Uint8ClampedArray(new ArrayBuffer(4)),\n            height: 1,\n            width: 1,\n        };\n    }\n    function getRegionMaskCoverageTransfers(coverage) {\n        return coverage?.entries.map(({ data }) => data.buffer) ?? [];\n    }\n    function createImageBitmapFromImageData(imageData) {\n        if (typeof OffscreenCanvas === \"undefined\") {\n            return null;\n        }\n        const canvas = new OffscreenCanvas(imageData.width, imageData.height);\n        const context = canvas.getContext(\"2d\");\n        if (!context) {\n            return null;\n        }\n        context.putImageData(imageData, 0, 0);\n        return canvas.transferToImageBitmap();\n    }\n\n})();";
+const EMBEDDED_MASK_PREPARATION_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        /**\n         * The playback gate is holding playback until the source produces detections\n         * for the requested range. {@link DetectionBufferStatus.Loading} fetches\n         * detections the source already has; this one waits on a producer.\n         */\n        DetectionBufferStatus[\"AwaitingCoverage\"] = \"awaitingCoverage\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         *\n         * Frame times must come from the media itself. Times reconstructed from a\n         * nominal frame rate drift against a clip whose real rate differs, and once\n         * that drift passes the half-millisecond selection tolerance a playhead\n         * landing on a frame boundary selects the previous frame's detections.\n         *\n         * A frame that carries no `endTime` stays active until the next frame starts,\n         * which bridges an index the source never produced.\n         * {@link DetectionFrameSelectionMode.NearestFrameIndex} bounds each frame to\n         * one grid step instead, so a missing index reads as no detections.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex` and\n         * `frameRate`. This is useful when inference was run on normalized frames and\n         * playback should snap detections to that grid.\n         *\n         * A frame speaks for one grid step starting at its own media time, and an\n         * index the source never produced selects nothing rather than a neighbour.\n         *\n         * A frame carrying no `frameIndex` speaks for its step on the same terms,\n         * reached by the time it starts at rather than by an index that names it. Its\n         * `endTime` does not widen it past that step, so a source that labels only\n         * part of what it writes cannot bridge the indexes it never produced.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n    function decodeCompressedRleMask(mask) {\n        if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {\n            throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);\n        }\n        const data = new Uint8Array(mask.width * mask.height);\n        const counts = decodeCompressedRleCounts(mask.counts);\n        let offset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            const isForeground = index % 2 === 1;\n            if (isForeground) {\n                for (let runOffset = 0; runOffset < runLength; runOffset += 1) {\n                    const maskOffset = offset + runOffset;\n                    const x = Math.floor(maskOffset / mask.height);\n                    const y = maskOffset % mask.height;\n                    const rowMajorOffset = y * mask.width + x;\n                    if (rowMajorOffset < data.length) {\n                        data[rowMajorOffset] = 1;\n                    }\n                }\n            }\n            offset += runLength;\n        }\n        return {\n            data,\n            height: mask.height,\n            width: mask.width,\n        };\n    }\n    function decodeCompressedRleCounts(counts) {\n        const decoded = [];\n        let index = 0;\n        while (index < counts.length) {\n            let value = 0;\n            let shift = 0;\n            let charCode;\n            do {\n                charCode = counts.charCodeAt(index) - 48;\n                index += 1;\n                value |= (charCode & 0x1f) << shift;\n                shift += 5;\n            } while (charCode & 0x20);\n            if (charCode & 0x10) {\n                value |= -1 << shift;\n            }\n            if (decoded.length > 2) {\n                value += decoded[decoded.length - 2] ?? 0;\n            }\n            decoded.push(value);\n        }\n        return decoded;\n    }\n    function encodeCompressedRleCounts(counts) {\n        return counts\n            .map((count, index) => {\n            let value = index > 2 ? count - counts[index - 2] : count;\n            let encoded = \"\";\n            let more = true;\n            while (more) {\n                let charCode = value & 0x1f;\n                value >>= 5;\n                more = !((value === 0 && (charCode & 0x10) === 0) ||\n                    (value === -1 && (charCode & 0x10) !== 0));\n                if (more) {\n                    charCode |= 0x20;\n                }\n                encoded += String.fromCharCode(charCode + 48);\n            }\n            return encoded;\n        })\n            .join(\"\");\n    }\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n    function encodeBinaryMask(data, width, height) {\n        assertMaskDimensions(data, width, height);\n        const runs = [];\n        let currentValue = 0;\n        let runLength = 0;\n        for (let x = 0; x < width; x += 1) {\n            for (let y = 0; y < height; y += 1) {\n                const value = data[y * width + x] ? 1 : 0;\n                if (value === currentValue) {\n                    runLength += 1;\n                }\n                else {\n                    runs.push(runLength);\n                    currentValue = value;\n                    runLength = 1;\n                }\n            }\n        }\n        runs.push(runLength);\n        return {\n            counts: encodeCompressedRleCounts(runs),\n            encoding: DetectionMaskEncoding.CompressedRle,\n            height,\n            width,\n        };\n    }\n    function assertMaskSize(width, height) {\n        if (!Number.isInteger(width) || width <= 0) {\n            throw new Error(\"Mask width must be a positive integer.\");\n        }\n        if (!Number.isInteger(height) || height <= 0) {\n            throw new Error(\"Mask height must be a positive integer.\");\n        }\n    }\n    function assertMaskDimensions(data, width, height) {\n        assertMaskSize(width, height);\n        if (data.length !== width * height) {\n            throw new Error(\"Mask data length must equal width * height.\");\n        }\n    }\n\n    function centerRectToTopLeftRect(rect) {\n        return {\n            height: rect.height,\n            width: rect.width,\n            x: rect.x - rect.width / 2,\n            y: rect.y - rect.height / 2,\n        };\n    }\n    function getPointsRect(points) {\n        if (points.length === 0) {\n            return undefined;\n        }\n        let minX = Number.POSITIVE_INFINITY;\n        let minY = Number.POSITIVE_INFINITY;\n        let maxX = Number.NEGATIVE_INFINITY;\n        let maxY = Number.NEGATIVE_INFINITY;\n        for (const point of points) {\n            minX = Math.min(minX, point.x);\n            minY = Math.min(minY, point.y);\n            maxX = Math.max(maxX, point.x);\n            maxY = Math.max(maxY, point.y);\n        }\n        return {\n            height: maxY - minY,\n            width: maxX - minX,\n            x: (minX + maxX) / 2,\n            y: (minY + maxY) / 2,\n        };\n    }\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"OrientedBox\"] = \"orientedBox\";\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 PercentageBarPlacement;\n    (function (PercentageBarPlacement) {\n        PercentageBarPlacement[\"Top\"] = \"top\";\n        PercentageBarPlacement[\"Bottom\"] = \"bottom\";\n        PercentageBarPlacement[\"InsideTop\"] = \"insideTop\";\n        PercentageBarPlacement[\"InsideBottom\"] = \"insideBottom\";\n    })(PercentageBarPlacement || (PercentageBarPlacement = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n    function rasterizePolygonToMask(points, dimensions) {\n        const data = createEmptyMask(dimensions);\n        if (points.length < 3) {\n            return data;\n        }\n        const bounds = centerRectToTopLeftRect(getPointsRect(points));\n        const startY = Math.max(0, Math.floor(bounds.y));\n        const endY = Math.min(dimensions.height - 1, Math.ceil(bounds.y + bounds.height));\n        for (let y = startY; y <= endY; y += 1) {\n            const scanY = y + 0.5;\n            const intersections = [];\n            for (let index = 0; index < points.length; index += 1) {\n                const current = points[index];\n                const next = points[(index + 1) % points.length];\n                if ((current.y <= scanY && next.y > scanY) ||\n                    (next.y <= scanY && current.y > scanY)) {\n                    const ratio = (scanY - current.y) / (next.y - current.y);\n                    intersections.push(current.x + ratio * (next.x - current.x));\n                }\n            }\n            intersections.sort((left, right) => left - right);\n            for (let index = 0; index < intersections.length - 1; index += 2) {\n                const left = Math.max(0, Math.round(intersections[index]));\n                const right = Math.min(dimensions.width, Math.round(intersections[index + 1]));\n                for (let x = left; x < right; x += 1) {\n                    data[y * dimensions.width + x] = 1;\n                }\n            }\n        }\n        return data;\n    }\n    function createEmptyMask(dimensions) {\n        if (!Number.isInteger(dimensions.width) ||\n            dimensions.width <= 0 ||\n            !Number.isInteger(dimensions.height) ||\n            dimensions.height <= 0) {\n            throw new Error(\"Media dimensions must be positive integers.\");\n        }\n        return new Uint8Array(dimensions.width * dimensions.height);\n    }\n\n    /**\n     * Palette slots an id raster can name, one of them the background. A GLSL\n     * fragment stage is guaranteed only 224 uniform vectors, and a palette entry\n     * costs 2.25 of them, so this stays a multiple of four and well inside that\n     * budget; past it a frame draws from the RGBA composite instead.\n     */\n    const MAX_ID_MASK_PALETTE_ENTRIES = 80;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions, options = {}) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const maskWidth = Math.max(...instructions.map(({ mask }) => mask.width));\n        const maskHeight = Math.max(...instructions.map(({ mask }) => mask.height));\n        const width = resolveRasterWidth(maskWidth, options.maxWidth);\n        const height = width === maskWidth\n            ? maskHeight\n            : Math.max(1, Math.round((width * maskHeight) / maskWidth));\n        const scaledAxes = width === maskWidth\n            ? undefined\n            : createScaledMaskAxes({ height, maskHeight, maskWidth, width });\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        const fillPalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokePalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokeWidths = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4));\n        let hasStroke = false;\n        let maxStrokeWidth = 0;\n        for (const instruction of instructions) {\n            const detectionMaskId = resolveIdMaskPaletteId(instruction.detectionIndex);\n            if (detectionMaskId === undefined) {\n                return undefined;\n            }\n            writeIdMaskPaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);\n            if (instruction.stroke && instruction.stroke.width > 0) {\n                const strokeWidth = resolveIdMaskStrokeTexels(instruction.stroke.width, maskWidth, width);\n                hasStroke = true;\n                strokeWidths[detectionMaskId] = strokeWidth;\n                maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);\n                writeIdMaskPaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);\n            }\n            if (scaledAxes) {\n                writeScaledMaskRuns(data, scaledAxes, instruction.mask, detectionMaskId);\n            }\n            else {\n                writeMaskRuns(data, width, instruction.mask, detectionMaskId);\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            sourceWidth: maskWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\n    }\n    /**\n     * Compressed RLE counts runs down each column in turn, so a foreground run is\n     * a contiguous walk down one column that wraps into the next.\n     */\n    function writeMaskRuns(data, frameWidth, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let frameOffset = y * frameWidth + x;\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[frameOffset] = detectionMaskId;\n                y += 1;\n                frameOffset += frameWidth;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    frameOffset = x;\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    /**\n     * The scaled twin of writeMaskRuns. Every source pixel marks the texel it lands\n     * in, so a mask keeps every part of itself the smaller raster can hold and\n     * gains up to a texel at its edges.\n     */\n    function writeScaledMaskRuns(data, axes, mask, detectionMaskId) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        let maskOffset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let x = Math.floor(maskOffset / maskHeight);\n            let y = maskOffset - x * maskHeight;\n            let column = axes.columns[x];\n            for (let step = 0; step < runLength; step += 1) {\n                if (x >= maskWidth) {\n                    break;\n                }\n                data[axes.rows[y] + column] = detectionMaskId;\n                y += 1;\n                if (y === maskHeight) {\n                    y = 0;\n                    x += 1;\n                    column = axes.columns[x];\n                }\n            }\n            maskOffset += runLength;\n        }\n    }\n    function resolveRasterWidth(maskWidth, maxWidth) {\n        return maxWidth !== undefined && maxWidth > 0 && maxWidth < maskWidth\n            ? Math.max(1, Math.floor(maxWidth))\n            : maskWidth;\n    }\n    /**\n     * A stroke is measured in texels of the raster it is drawn on, so a coarser\n     * raster measures it in coarser texels. A stroke of a texel or more keeps at\n     * least one, the thinnest line the shader can draw; a narrower one keeps its\n     * own width, which the shader draws as an inner boundary at any scale. The\n     * ceiling is the widest neighbourhood the shaders scan, so a wider stroke would\n     * be drawn at the ceiling anyway and every layer drawing the same annotation\n     * has to arrive at the same width.\n     */\n    function resolveIdMaskStrokeTexels(strokeWidth, maskWidth, rasterWidth) {\n        const scale = maskWidth > 0 ? rasterWidth / maskWidth : 1;\n        return Math.min(Math.max(strokeWidth * scale, Math.min(strokeWidth, 1)), MAX_ID_MASK_STROKE_WIDTH);\n    }\n    function createScaledMaskAxes(frame) {\n        return {\n            columns: createMaskAxisMap(frame.maskWidth, frame.width, 1),\n            rows: createMaskAxisMap(frame.maskHeight, frame.height, frame.width),\n        };\n    }\n    /** Rows hold their destination offset, so writing a run is two lookups. */\n    function createMaskAxisMap(sourceLength, targetLength, stride) {\n        const map = new Int32Array(sourceLength);\n        const scale = targetLength / sourceLength;\n        for (let index = 0; index < sourceLength; index += 1) {\n            map[index] = Math.min(targetLength - 1, Math.floor(index * scale)) * stride;\n        }\n        return map;\n    }\n    /**\n     * The palette slot a detection index names, or undefined when the palette has\n     * no slot for it. Slot zero is the background, so the ids start at one and the\n     * last detection the palette can name sits one index below the last slot.\n     */\n    function resolveIdMaskPaletteId(detectionIndex) {\n        const detectionMaskId = detectionIndex + 1;\n        return detectionMaskId > 0 && detectionMaskId < MAX_ID_MASK_PALETTE_ENTRIES\n            ? detectionMaskId\n            : undefined;\n    }\n    function writeIdMaskPaletteEntry(palette, detectionMaskId, color, alpha) {\n        const offset = detectionMaskId * 4;\n        palette[offset] = ((color >> 16) & 0xff) / 255;\n        palette[offset + 1] = ((color >> 8) & 0xff) / 255;\n        palette[offset + 2] = (color & 0xff) / 255;\n        palette[offset + 3] = Math.max(0, Math.min(alpha, 1));\n    }\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Stable classification of a media failure.\n     *\n     * Applications branch on these kinds instead of parsing decoder, demuxer, or\n     * container error text, and still own their localized user-facing copy. New\n     * kinds may be added over time, so treat unrecognized values like `Unknown`.\n     */\n    var MediaErrorKind;\n    (function (MediaErrorKind) {\n        /** The media could not be opened or read, or was refused before any read. */\n        MediaErrorKind[\"Unreadable\"] = \"unreadable\";\n        /** The container or codec is not supported by this platform. */\n        MediaErrorKind[\"UnsupportedFormat\"] = \"unsupportedFormat\";\n        /** The media opened but carries no usable video track. */\n        MediaErrorKind[\"NoVideoTrack\"] = \"noVideoTrack\";\n        /** Decoding a sample failed after the source opened. */\n        MediaErrorKind[\"Decode\"] = \"decode\";\n        /** The media could not be fetched. */\n        MediaErrorKind[\"Network\"] = \"network\";\n        /** The host environment lacks the APIs this media source requires. */\n        MediaErrorKind[\"EnvironmentUnsupported\"] = \"environmentUnsupported\";\n        /** The failure could not be classified. */\n        MediaErrorKind[\"Unknown\"] = \"unknown\";\n    })(MediaErrorKind || (MediaErrorKind = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n    /**\n     * Current renderer state.\n     */\n    /**\n     * What a playback gate holds back.\n     *\n     * A source the renderer pulls samples from can be held between any two frames,\n     * because the renderer decides when each one is drawn. A source that presents\n     * its own frames owns the playhead, so holding it means stopping the producer\n     * and starting it again, and a gate that stops one has to bound its own wait\n     * or a producer nothing answers for never runs again.\n     */\n    var PlaybackGateReach;\n    (function (PlaybackGateReach) {\n        /** No gate: the picture moves and unprepared layers are absent from it. */\n        PlaybackGateReach[\"Off\"] = \"off\";\n        /**\n         * Playback waits to begin, and stops again at any frame whose artifacts are\n         * missing, until they arrive or the gate's own wait bound gives up on them.\n         */\n        PlaybackGateReach[\"EveryFrame\"] = \"everyFrame\";\n    })(PlaybackGateReach || (PlaybackGateReach = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        /**\n         * Playback is held waiting for a producer to emit detections for the frame\n         * about to be shown, which is a wait on inference rather than on transfer or\n         * decode. `DetectionsBuffering` is the transfer of detections that already\n         * exist, and `PlaybackBuffering` is the wait for media bytes.\n         */\n        MediaSessionActivityKind[\"DetectionsAwaitingCoverage\"] = \"detectionsAwaitingCoverage\";\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        /**\n         * The picture is waiting on media the source has not handed over yet, which\n         * is the bytes and their decode rather than anything downstream of them.\n         * `PlaybackBuffering` is what a transport reports once it has already\n         * stopped; this is reported from the read itself, including the reads a seek\n         * makes while the transport still reads as paused.\n         */\n        MediaSessionActivityKind[\"MediaSourceReading\"] = \"mediaSourceReading\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        /**\n         * The render-preparation gate held the picture for artifacts that never\n         * arrived and let it go. Nothing is blocked: the frames reaching the screen\n         * are the ones whose artifacts were given up on. What is waited on is\n         * preparation finishing another frame, which is what lets the gate hold the\n         * picture again; `RenderPreparing` covers the holds that are running.\n         */\n        MediaSessionActivityKind[\"RenderPreparationAbandoned\"] = \"renderPreparationAbandoned\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    /** Builds compact, independent alpha crops so overlapping masks stay exact. */\n    function createRegionMaskCoverageFrame(instructions) {\n        const entries = [];\n        for (const instruction of instructions) {\n            if (!instruction.regionCoverageMask) {\n                continue;\n            }\n            const entry = cropCoverageMask(instruction.detectionIndex, decodeCompressedRleMask(instruction.regionCoverageMask));\n            if (entry) {\n                entries.push(entry);\n            }\n        }\n        return entries.length > 0 ? { entries } : undefined;\n    }\n    function cropCoverageMask(detectionIndex, decodedMask) {\n        let minX = decodedMask.width;\n        let minY = decodedMask.height;\n        let maxX = -1;\n        let maxY = -1;\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                minX = Math.min(minX, x);\n                minY = Math.min(minY, y);\n                maxX = Math.max(maxX, x);\n                maxY = Math.max(maxY, y);\n            }\n        }\n        if (maxX < minX || maxY < minY) {\n            return undefined;\n        }\n        const width = maxX - minX + 1;\n        const height = maxY - minY + 1;\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        for (let y = minY; y <= maxY; y += 1) {\n            for (let x = minX; x <= maxX; x += 1) {\n                if (!decodedMask.data[y * decodedMask.width + x]) {\n                    continue;\n                }\n                data[(y - minY) * width + (x - minX)] = 255;\n            }\n        }\n        return { data, detectionIndex, height, width, x: minX, y: minY };\n    }\n    function compositeMaskFrame(instructions) {\n        const maskInstructions = materializeMaskInstructions(instructions);\n        if (maskInstructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...maskInstructions.map(({ mask }) => mask.width));\n        const height = Math.max(...maskInstructions.map(({ mask }) => mask.height));\n        const data = new Uint8ClampedArray(new ArrayBuffer(width * height * 4));\n        for (const instruction of maskInstructions) {\n            compositeInstruction(data, width, instruction);\n        }\n        return { data, height, width };\n    }\n    function createIdMaskRasterFrame(instructions, maxRasterWidth) {\n        try {\n            return createIdMaskFrame(materializeMaskInstructions(instructions), {\n                maxWidth: maxRasterWidth,\n            });\n        }\n        catch {\n            // The id raster is the fast path, not the only one: answering with nothing\n            // puts the caller on the RGBA composite, which draws the same picture.\n            return undefined;\n        }\n    }\n    /**\n     * Whether the palette has a slot for every detection this frame masks. An id\n     * names a detection by its index in the frame, so one masked detection past the\n     * last slot leaves the whole frame without an id raster however few masks it\n     * carries.\n     */\n    function canIdMaskPaletteNameFrame(instructions) {\n        return instructions.every((instruction) => instruction.visible === false ||\n            resolveIdMaskPaletteId(instruction.detectionIndex) !== undefined);\n    }\n    function createIdMaskPlane(instructions, maxRasterWidth) {\n        // The plane carries the ids a failed cook could not. A frame the palette\n        // cannot name has none to carry, and cooking it again reaches the same\n        // refusal after rasterizing every mask a second time.\n        if (!canIdMaskPaletteNameFrame(instructions)) {\n            return undefined;\n        }\n        const frame = createIdMaskRasterFrame(instructions, maxRasterWidth);\n        return frame\n            ? { data: frame.data, height: frame.height, width: frame.width }\n            : undefined;\n    }\n    function compositeInstruction(rgba, canvasWidth, instruction) {\n        const fill = resolveRgbaColor(instruction.color, instruction.alpha);\n        const bounds = compositeMaskFill(rgba, canvasWidth, instruction.mask, fill);\n        if (instruction.stroke && bounds) {\n            compositeMaskStroke(rgba, canvasWidth, decodeCompressedRleMask(instruction.mask), bounds, instruction.stroke);\n        }\n    }\n    function materializeMaskInstructions(instructions) {\n        return instructions\n            .filter((instruction) => instruction.visible !== false)\n            .map((instruction) => {\n            if (instruction.mask) {\n                return instruction;\n            }\n            const { height, points, width } = instruction.polygon;\n            return {\n                alpha: instruction.alpha,\n                color: instruction.color,\n                detectionIndex: instruction.detectionIndex,\n                mask: encodeBinaryMask(rasterizePolygonToMask(points, { height, width }), width, height),\n                stroke: instruction.stroke,\n            };\n        });\n    }\n    /**\n     * Compressed RLE counts runs down each column in turn, so a foreground run is\n     * a contiguous walk down one column that wraps into the next.\n     */\n    function compositeMaskFill(rgba, canvasWidth, mask, fill) {\n        const counts = decodeCompressedRleCounts(mask.counts);\n        const maskWidth = mask.width;\n        const maskHeight = mask.height;\n        const maskArea = maskWidth * maskHeight;\n        let maskOffset = 0;\n        let minX = maskWidth;\n        let minY = maskHeight;\n        let maxX = -1;\n        let maxY = -1;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            if (index % 2 === 0 || runLength <= 0) {\n                maskOffset += runLength;\n                continue;\n            }\n            let columnX = Math.floor(maskOffset / maskHeight);\n            let columnY = maskOffset - columnX * maskHeight;\n            for (let step = 0; step < runLength; step += 1) {\n                // A run can outlast the columns the mask has; the pixel it then names\n                // is wherever that column-major offset lands when read back row-major.\n                const rowMajorOffset = columnY * maskWidth + columnX;\n                if (rowMajorOffset < maskArea) {\n                    const x = rowMajorOffset % maskWidth;\n                    const y = (rowMajorOffset - x) / maskWidth;\n                    writePixel(rgba, canvasWidth, x, y, fill);\n                    minX = Math.min(minX, x);\n                    minY = Math.min(minY, y);\n                    maxX = Math.max(maxX, x);\n                    maxY = Math.max(maxY, y);\n                }\n                columnY += 1;\n                if (columnY === maskHeight) {\n                    columnY = 0;\n                    columnX += 1;\n                }\n            }\n            maskOffset += runLength;\n        }\n        return maxX < minX || maxY < minY ? undefined : { maxX, maxY, minX, minY };\n    }\n    function compositeMaskStroke(rgba, canvasWidth, decodedMask, bounds, stroke) {\n        const width = Math.round(stroke.width);\n        if (width <= 0) {\n            return;\n        }\n        const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);\n        for (let y = bounds.minY; y <= bounds.maxY; y += 1) {\n            for (let x = bounds.minX; x <= bounds.maxX; x += 1) {\n                if (!isMaskPixel(decodedMask, x, y) ||\n                    !isBoundaryPixel(decodedMask, x, y)) {\n                    continue;\n                }\n                for (let offsetY = -width; offsetY <= width; offsetY += 1) {\n                    for (let offsetX = -width; offsetX <= width; offsetX += 1) {\n                        const strokeX = x + offsetX;\n                        const strokeY = y + offsetY;\n                        if (isOutsideMaskBounds(decodedMask, strokeX, strokeY) ||\n                            isMaskPixel(decodedMask, strokeX, strokeY)) {\n                            continue;\n                        }\n                        writePixel(rgba, canvasWidth, strokeX, strokeY, strokeColor);\n                    }\n                }\n            }\n        }\n    }\n    function isBoundaryPixel(mask, x, y) {\n        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {\n            for (let offsetX = -1; offsetX <= 1; offsetX += 1) {\n                if (offsetX === 0 && offsetY === 0) {\n                    continue;\n                }\n                const neighborX = x + offsetX;\n                const neighborY = y + offsetY;\n                if (isOutsideMaskBounds(mask, neighborX, neighborY) ||\n                    !isMaskPixel(mask, neighborX, neighborY)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    function isMaskPixel(mask, x, y) {\n        return mask.data[y * mask.width + x] === 1;\n    }\n    function isOutsideMaskBounds(mask, x, y) {\n        return x < 0 || y < 0 || x >= mask.width || y >= mask.height;\n    }\n    function resolveRgbaColor(color, alpha) {\n        return {\n            alpha: Math.round(Math.max(0, Math.min(alpha, 1)) * 255),\n            blue: color & 0xff,\n            green: (color >> 8) & 0xff,\n            red: (color >> 16) & 0xff,\n        };\n    }\n    function writePixel(rgba, canvasWidth, x, y, color) {\n        const rgbaOffset = (y * canvasWidth + x) * 4;\n        rgba[rgbaOffset] = color.red;\n        rgba[rgbaOffset + 1] = color.green;\n        rgba[rgbaOffset + 2] = color.blue;\n        rgba[rgbaOffset + 3] = color.alpha;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"IdMask\"] = \"idMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\n    /**\n     * How an id raster is laid out for the texture it is uploaded into. WebGPU\n     * takes any bytesPerRow, so ids go up one byte per pixel. WebGL aligns every\n     * uploaded row to four bytes and rejects a single-channel upload whose width\n     * is not a multiple of four, which is what the four-channel layout is for.\n     */\n    var IdMaskTextureFormat;\n    (function (IdMaskTextureFormat) {\n        IdMaskTextureFormat[\"R8\"] = \"r8unorm\";\n        IdMaskTextureFormat[\"Rgba8\"] = \"rgba8unorm\";\n    })(IdMaskTextureFormat || (IdMaskTextureFormat = {}));\n\n    var MaskPreparationWorkerMessageType;\n    (function (MaskPreparationWorkerMessageType) {\n        MaskPreparationWorkerMessageType[\"Complete\"] = \"complete\";\n        MaskPreparationWorkerMessageType[\"Empty\"] = \"empty\";\n        MaskPreparationWorkerMessageType[\"Error\"] = \"error\";\n        MaskPreparationWorkerMessageType[\"Prepare\"] = \"prepare\";\n    })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));\n\n    const workerScope = globalThis;\n    workerScope.addEventListener(\"message\", (event) => {\n        const message = event.data;\n        if (message.type !== MaskPreparationWorkerMessageType.Prepare) {\n            return;\n        }\n        prepareMaskFrame(message);\n    });\n    function prepareMaskFrame(message) {\n        try {\n            const regionMaskCoverage = createRegionMaskCoverageFrame(message.job.instructions);\n            const coverageTransfers = getRegionMaskCoverageTransfers(regionMaskCoverage);\n            const idMaskFrame = createIdMaskRasterFrame(message.job.instructions, message.job.maxRasterWidth);\n            if (idMaskFrame) {\n                workerScope.postMessage({\n                    artifactKind: PreparedMaskFrameKind.IdMask,\n                    fillPalette: idMaskFrame.fillPalette,\n                    hasStroke: idMaskFrame.hasStroke,\n                    height: idMaskFrame.height,\n                    key: message.job.key,\n                    maxStrokeWidth: idMaskFrame.maxStrokeWidth,\n                    raster: idMaskFrame.data,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    sourceWidth: idMaskFrame.sourceWidth,\n                    strokePalette: idMaskFrame.strokePalette,\n                    strokeWidths: idMaskFrame.strokeWidths,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                    width: idMaskFrame.width,\n                }, [\n                    idMaskFrame.data.buffer,\n                    idMaskFrame.fillPalette.buffer,\n                    idMaskFrame.strokePalette.buffer,\n                    idMaskFrame.strokeWidths.buffer,\n                    ...coverageTransfers,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame && !regionMaskCoverage) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const preparedPixels = compositedFrame ?? createTransparentCoverageCarrier();\n            const imageData = new ImageData(preparedPixels.data, preparedPixels.width, preparedPixels.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            const idMaskPlane = createIdMaskPlane(message.job.instructions, message.job.maxRasterWidth);\n            const idMaskTransfers = idMaskPlane ? [idMaskPlane.data.buffer] : [];\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    idMaskPlane,\n                    imageBitmap,\n                    key: message.job.key,\n                    regionMaskCoverage,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [imageBitmap, ...idMaskTransfers, ...coverageTransfers]);\n                return;\n            }\n            workerScope.postMessage({\n                idMaskPlane,\n                imageData,\n                key: message.job.key,\n                regionMaskCoverage,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [imageData.data.buffer, ...idMaskTransfers, ...coverageTransfers]);\n        }\n        catch (error) {\n            workerScope.postMessage({\n                error: error instanceof Error\n                    ? error.message\n                    : \"Unable to prepare mask frame.\",\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Error,\n            });\n        }\n    }\n    /**\n     * A frame that carries only region coverage has nothing to composite, and the\n     * RGBA branch still has to produce an artifact for the coverage to ride on.\n     */\n    function createTransparentCoverageCarrier() {\n        return {\n            data: new Uint8ClampedArray(new ArrayBuffer(4)),\n            height: 1,\n            width: 1,\n        };\n    }\n    function getRegionMaskCoverageTransfers(coverage) {\n        return coverage?.entries.map(({ data }) => data.buffer) ?? [];\n    }\n    function createImageBitmapFromImageData(imageData) {\n        if (typeof OffscreenCanvas === \"undefined\") {\n            return null;\n        }\n        const canvas = new OffscreenCanvas(imageData.width, imageData.height);\n        const context = canvas.getContext(\"2d\");\n        if (!context) {\n            return null;\n        }\n        context.putImageData(imageData, 0, 0);\n        return canvas.transferToImageBitmap();\n    }\n\n})();";
 
 const DEFAULT_WORKER_NAME = "supervision-js-render-preparation";
 let defaultWorkerUrl;
@@ -9505,7 +9509,9 @@ function drawShapeInstruction(graphics, instruction, viewportScale) {
             graphics.poly(segment.flatMap(({ x, y }) => [x, y]), true);
             graphics.fill(instruction.fill);
         }
-        drawPixiPath(graphics, segment, instruction.closed, instruction.stroke, viewportScale);
+        if (instruction.stroke) {
+            drawPixiPath(graphics, segment, instruction.closed, instruction.stroke, viewportScale);
+        }
     }
 }
 function drawMarkerInstruction(graphics, instruction, viewportScale) {
@@ -11425,7 +11431,13 @@ function resolveAnnotationShapeStyle(styles) {
     const boxCornerStyle = styles.boxCornerStyle ?? null;
     const ellipseStyle = styles.ellipseStyle ?? null;
     const markerStyle = styles.markerStyle ?? null;
-    if (!boxCornerStyle && !ellipseStyle && !markerStyle) {
+    const orientedBoxStyle = styles.orientedBoxStyle ?? null;
+    const percentageBarStyle = styles.percentageBarStyle ?? null;
+    if (!boxCornerStyle &&
+        !ellipseStyle &&
+        !markerStyle &&
+        !orientedBoxStyle &&
+        !percentageBarStyle) {
         return null;
     }
     return {
@@ -11448,13 +11460,66 @@ function resolveAnnotationShapeStyle(styles) {
             if (ellipse) {
                 instructions.push(lowerEllipseInstruction(ellipse));
             }
+            const orientedBox = orientedBoxStyle?.resolve(detection, context);
+            if (orientedBox) {
+                instructions.push(lowerOrientedBoxInstruction(orientedBox));
+            }
+            const percentageBar = percentageBarStyle?.resolve(detection, context);
+            if (percentageBar) {
+                lowerPercentageBarInstructions(percentageBar, instructions);
+            }
             return instructions.length > 0 ? instructions : undefined;
         },
     };
 }
+function lowerPercentageBarInstructions(bar, target) {
+    if (bar.background) {
+        target.push({
+            closed: true,
+            fill: bar.background,
+            kind: ShapeInstructionKind.Path,
+            segments: [rectToPolygonPoints(bar.backgroundRect)],
+        });
+    }
+    if (bar.fill && bar.valueRect.width > 0) {
+        target.push({
+            closed: true,
+            fill: bar.fill,
+            kind: ShapeInstructionKind.Path,
+            segments: [rectToPolygonPoints(bar.valueRect)],
+        });
+    }
+    if (bar.border) {
+        target.push({
+            closed: true,
+            kind: ShapeInstructionKind.Path,
+            segments: [rectToPolygonPoints(bar.backgroundRect)],
+            stroke: bar.border,
+        });
+    }
+}
+function rectToPolygonPoints(rect) {
+    const halfWidth = rect.width / 2;
+    const halfHeight = rect.height / 2;
+    return [
+        { x: rect.x - halfWidth, y: rect.y - halfHeight },
+        { x: rect.x + halfWidth, y: rect.y - halfHeight },
+        { x: rect.x + halfWidth, y: rect.y + halfHeight },
+        { x: rect.x - halfWidth, y: rect.y + halfHeight },
+    ];
+}
 function lowerEllipseInstruction(instruction) {
     return { ...instruction, kind: ShapeInstructionKind.Ellipse };
 }
+function lowerOrientedBoxInstruction(instruction) {
+    return {
+        closed: true,
+        fill: instruction.fill,
+        kind: ShapeInstructionKind.Path,
+        segments: [instruction.points],
+        stroke: instruction.stroke,
+    };
+}
 
 /**
  * Produces a per-detection alpha mask from a compact prepared coverage crop.
@@ -12477,8 +12542,8 @@ function drawEditingPreview(graphics, engine, frame, viewportScale, style, keypo
     const boxFill = resolveStyleValue(style.editingPreview.boxFill, detection, styleContext);
     const polygonFill = resolveStyleValue(style.editingPreview.polygonFill, detection, styleContext);
     const closeZoneStroke = resolveStyleValue(style.editingPreview.closeZoneStroke, detection, styleContext);
-    // A skeleton's rect is part of its geometry, so it previews alongside the
-    // keypoints; polygon, polyline and mask rects are derived bounds and are not.
+    // Rects coexist with keypoints and OBBs as independent editable geometry.
+    // Polygon, polyline and mask rects are derived bounds instead.
     if (detection.rect &&
         !detection.mask &&
         !detection.polygon &&
@@ -12506,6 +12571,13 @@ function drawEditingPreview(graphics, engine, frame, viewportScale, style, keypo
             .fill(polygonFill);
         drawPixiPath(graphics, detection.polygon.points, true, stroke, viewportScale);
     }
+    // Keep the OBB's own vertices visible alongside any independent rect.
+    if (detection.orientedBox) {
+        graphics
+            .poly(detection.orientedBox.points.flatMap(({ x, y }) => [x, y]), true)
+            .fill(polygonFill);
+        drawPixiPath(graphics, detection.orientedBox.points, true, stroke, viewportScale);
+    }
     if (detection.polyline)
         drawPixiPath(graphics, detection.polyline.points, false, stroke, viewportScale);
     if (detection.keypoints && keypointStyle) {
@@ -12966,6 +13038,8 @@ async function createPixiMediaScene(options) {
     let currentBoxCornerStyle = options.boxCornerStyle ?? null;
     let currentEllipseStyle = options.ellipseStyle ?? null;
     let currentMarkerStyle = options.markerStyle ?? null;
+    let currentOrientedBoxStyle = options.orientedBoxStyle ?? null;
+    let currentPercentageBarStyle = options.percentageBarStyle ?? null;
     let currentRegionRenderers = options.regionRenderers;
     let regionMaskCoverageKey = resolveRegionMaskCoverageKey(currentRegionRenderers);
     let currentPolygonStyle = options.polygonStyle === undefined
@@ -13910,7 +13984,9 @@ async function createPixiMediaScene(options) {
             annotationOverlayLayer.setKeypointStyle(presentation.keypointStyle);
             if (presentation.boxCornerStyle !== undefined ||
                 presentation.ellipseStyle !== undefined ||
-                presentation.markerStyle !== undefined) {
+                presentation.markerStyle !== undefined ||
+                presentation.orientedBoxStyle !== undefined ||
+                presentation.percentageBarStyle !== undefined) {
                 if (presentation.boxCornerStyle !== undefined) {
                     currentBoxCornerStyle = presentation.boxCornerStyle;
                 }
@@ -13920,6 +13996,12 @@ async function createPixiMediaScene(options) {
                 if (presentation.markerStyle !== undefined) {
                     currentMarkerStyle = presentation.markerStyle;
                 }
+                if (presentation.orientedBoxStyle !== undefined) {
+                    currentOrientedBoxStyle = presentation.orientedBoxStyle;
+                }
+                if (presentation.percentageBarStyle !== undefined) {
+                    currentPercentageBarStyle = presentation.percentageBarStyle;
+                }
                 vectorLayer.setStyles({ shapeStyle: resolveVectorShapeStyle() });
             }
             currentRegionRenderers =
@@ -14320,15 +14402,17 @@ async function createPixiMediaScene(options) {
         };
     }
     /**
-     * The vector layer takes one shape style, and the ellipse, marker and
-     * box-corner renderer kinds all lower to shape instructions, so they are
-     * composed onto whatever style the caller passed.
+     * The vector layer takes one shape style, and the ellipse, marker,
+     * box-corner, and oriented-box renderer kinds all lower to shape
+     * instructions, so they are composed onto whatever style the caller passed.
      */
     function resolveVectorShapeStyle() {
         const kindShapeStyle = resolveAnnotationShapeStyle({
             boxCornerStyle: currentBoxCornerStyle,
             ellipseStyle: currentEllipseStyle,
             markerStyle: currentMarkerStyle,
+            orientedBoxStyle: currentOrientedBoxStyle,
+            percentageBarStyle: currentPercentageBarStyle,
         });
         const baseShapeStyle = options.shapeStyle ?? null;
         if (!kindShapeStyle || !baseShapeStyle) {
@@ -15875,6 +15959,8 @@ async function createMediaSession(options) {
             maskHaloStyle: initialPresentation.maskHaloStyle,
             maskStyle: initialPresentation.maskStyle,
             markerStyle: initialPresentation.markerStyle,
+            orientedBoxStyle: initialPresentation.orientedBoxStyle,
+            percentageBarStyle: initialPresentation.percentageBarStyle,
             polygonStyle: initialPresentation.polygonStyle,
             polylineStyle: initialPresentation.polylineStyle,
             renderers: initialPresentation.renderers,