supervision 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,5 +1,5 @@
-import { copySortedDetectionFrames, detectionFrameOverlapsRange, includeDefined, MediaSourceStatus, MediaRendererPlaybackState, MediaRendererFit, createDefaultAnnotationPresentation, createArrayDetectionFrameSource, createBufferedDetectionTimeline, resolveAnnotationRendererPresentation, createIdleDetectionBufferState, MediaInteractionMode, BoxStrokeAlignment, BaseBoxStyle, centerRectToTopLeftRect, BoxShape, BaseFocusStyle, decodeCompressedRleMask, extractMaskRectRuns, AnnotationGestureStateKind, AnnotationHandleKind, getDetectionRect, DetectionPickTarget, createDetectionPickKey, rebaseDetectionPickToFrame, pickDetectionAtPoint, pickAnnotationHandle, getAnnotationHandles, createIdMaskFrame, encodeBinaryMask, rasterizePolygonToMask, LabelPlacement, BasePolygonStyle, BasePolylineStyle, BaseKeypointStyle, KeypointMarkerShape, BaseInteractionStyle, DetectionInteractionState, MAX_ID_MASK_PALETTE_ENTRIES, DetectionBufferStatus, canReuseMaskStyleArtifacts, getBufferedDetectionTimelineFrameSnapshot, MAX_ID_MASK_STROKE_WIDTH, resolveMaskStyleOpacity, pickDetectionByMaskId, resolveStyleValue, lightenColor, createViewportController, resolveAnnotationStyleState, MediaSessionMode, DetectionFrameRetentionMode, createMemoryColdDetectionFrameStore, createWritableDetectionFrameSource, createCompositeDetectionFrameSource, MediaSessionActivityStatus, MediaSessionActivityKind, MediaSessionStatus, createSourceAwarePresentation } from 'supervision-js-core';
-export { BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MaskRenderMode, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, SUPERVISION_ROBOFLOW_COLOR, annotationRendererKinds, annotationRenderers, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createMemoryColdDetectionFrameStore, createWritableDetectionFrameSource, normalizeDetectionClassName, pickDetectionAtPoint, resolveDetectionClassColorStyle } from 'supervision-js-core';
+import { copySortedDetectionFrames, detectionFrameOverlapsRange, projectDetectionFrameForTracking, createSortTracker, createOCSortTracker, createCBIoUTracker, createByteTrackTracker, includeDefined, MediaSourceStatus, MediaRendererPlaybackState, MediaRendererFit, createDefaultAnnotationPresentation, createArrayDetectionFrameSource, createBufferedDetectionTimeline, resolveAnnotationRendererPresentation, createIdleDetectionBufferState, MediaInteractionMode, StrokeAlignment, BaseBoxStyle, centerRectToTopLeftRect, BoxShape, BaseFocusStyle, decodeCompressedRleMask, extractMaskRectRuns, AnnotationGestureStateKind, AnnotationHandleKind, getDetectionRect, DetectionPickTarget, createDetectionPickKey, rebaseDetectionPickToFrame, pickDetectionAtPoint, followDetectionPickAcrossFrames, haveSameDetectionPickIdentities, pickAnnotationHandle, getAnnotationHandles, createIdMaskFrame, encodeBinaryMask, rasterizePolygonToMask, LabelPlacement, BasePolygonStyle, BasePolylineStyle, BaseKeypointStyle, KeypointMarkerShape, MarkerSizeSpace, MarkerShape, ShapeInstructionKind, sampleEllipseArc, resolveEllipseSegmentCount, resolveMarkerGeometry, BaseInteractionStyle, DetectionInteractionState, MAX_ID_MASK_PALETTE_ENTRIES, DetectionBufferStatus, canReuseMaskStyleArtifacts, getBufferedDetectionTimelineFrameSnapshot, MAX_ID_MASK_STROKE_WIDTH, resolveMaskStyleOpacity, pickDetectionByMaskId, BoxStrokeAlignment, resolveStyleValue, resolveAnnotationStyleState, lightenColor, createViewportController, MediaSessionMode, DetectionFrameRetentionMode, createMemoryColdDetectionFrameStore, createWritableDetectionFrameSource, createCompositeDetectionFrameSource, MediaSessionActivityStatus, MediaSessionActivityKind, MediaSessionStatus, createSourceAwarePresentation } from 'supervision-js-core';
+export { BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MarkerShape, MarkerSizeSpace, MaskRenderMode, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, RegionRendererComposeMode, RegionRendererRegionKind, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, TrackingGeometry, annotationRendererKinds, annotationRenderers, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createMemoryColdDetectionFrameStore, createOCSortTracker, createSortTracker, createWritableDetectionFrameSource, detectionPostProcessors, normalizeDetectionClassName, pickDetectionAtPoint, projectDetectionFrameForTracking, resolveDetectionClassColorStyle } from 'supervision-js-core';
 
 const DEFAULT_DATABASE_NAME = "supervision-js-detection-frames";
 const DEFAULT_CHUNK_DURATION_SECONDS = 1;
@@ -458,6 +458,434 @@ function getDetectionFrameDedupeKey(frame) {
         : `index:${frame.frameIndex}`;
 }
 
+const EMBEDDED_TRACKING_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex`, `frameRate`,\n         * and optional `frameIndexOriginTime`. This is useful when inference was run\n         * on normalized frames and playback should snap detections to that grid.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /**\n     * Creates one stateful SORT tracker for a single ordered media sequence.\n     *\n     * Defaults, lifecycle semantics, and observation-only output mirror\n     * roboflow/trackers SORT. Motion predictions remain internal to association.\n     */\n    function createSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.25;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                const predicted = tracks.map((track) => track.predict(frameStep, frameRate));\n                const { matches, unmatchedDetections } = associateDetectionsToTracks(detections, predicted, minimumIouThreshold);\n                const trackerIds = new Map();\n                for (const match of matches) {\n                    const track = tracks[match.trackIndex];\n                    const detection = detections[match.detectionIndex];\n                    track.update(detection);\n                    if (track.trackerId === undefined &&\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        track.trackerId = nextTrackerId;\n                        nextTrackerId += 1;\n                    }\n                    if (track.trackerId !== undefined) {\n                        trackerIds.set(detection.detectionIndex, track.trackerId);\n                    }\n                }\n                for (const detectionIndex of unmatchedDetections) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection));\n                    }\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = trackerIds.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n    }\n    class KalmanBoxTrack {\n        consecutiveUpdates;\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        state;\n        covariance = identity(8);\n        constructor(detection, consecutiveUpdates = false) {\n            this.consecutiveUpdates = consecutiveUpdates;\n            this.state = [...rectToXyxy(detection.rect), 0, 0, 0, 0].map((value) => [\n                value,\n            ]);\n        }\n        predict(frameStep, frameRate) {\n            if (this.consecutiveUpdates && this.timeSinceUpdate > 0) {\n                this.successfulUpdates = 0;\n            }\n            const transition = identity(8);\n            for (let index = 0; index < 4; index += 1) {\n                transition[index][index + 4] = frameStep;\n            }\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), createProcessNoise(frameStep, frameRate));\n            // Python SORT counts update calls for the fixed-rate lost-track budget.\n            this.timeSinceUpdate += 1;\n            return stateToRect(this.state);\n        }\n        update(detection) {\n            const measurement = rectToXyxy(detection.rect).map((value) => [value]);\n            const observation = [\n                [1, 0, 0, 0, 0, 0, 0, 0],\n                [0, 1, 0, 0, 0, 0, 0, 0],\n                [0, 0, 1, 0, 0, 0, 0, 0],\n                [0, 0, 0, 1, 0, 0, 0, 0],\n            ];\n            const measurementNoise = scale(identity(4), 0.1);\n            const innovation = subtract(measurement, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(8), multiply(gain, observation));\n            // Joseph form matches the Python implementation and is more stable.\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, measurementNoise), transpose(gain)));\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getStateRect() {\n            return stateToRect(this.state);\n        }\n    }\n    function associateDetectionsToTracks(detections, predicted, minimumIouThreshold) {\n        if (predicted.length === 0 || detections.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetections: detections.map((_, index) => index),\n            };\n        }\n        // Python SORT associates all detections class-agnostically using standard IoU.\n        const scores = predicted.map((rect) => detections.map((detection) => intersectionOverUnion(rect, detection.rect)));\n        const candidateMatches = maximizeAssignment(scores);\n        const matches = [];\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of candidateMatches) {\n            if (scores[trackIndex][detectionIndex] < minimumIouThreshold)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetections: detections.flatMap((_, index) => matchedDetections.has(index) ? [] : [index]),\n        };\n    }\n    /** Hungarian assignment for a rectangular score matrix. */\n    function maximizeAssignment(scores) {\n        if (scores.length === 0 || scores[0]?.length === 0) {\n            return [];\n        }\n        const rowCount = scores.length;\n        const columnCount = scores[0].length;\n        const transposed = rowCount > columnCount;\n        const costs = transposed\n            ? Array.from({ length: columnCount }, (_, row) => Array.from({ length: rowCount }, (_, column) => 1 - scores[column][row]))\n            : scores.map((row) => row.map((score) => 1 - score));\n        const rows = costs.length;\n        const columns = costs[0].length;\n        const u = new Array(rows + 1).fill(0);\n        const v = new Array(columns + 1).fill(0);\n        const p = new Array(columns + 1).fill(0);\n        const way = new Array(columns + 1).fill(0);\n        for (let row = 1; row <= rows; row += 1) {\n            p[0] = row;\n            let column0 = 0;\n            const minValue = new Array(columns + 1).fill(Number.POSITIVE_INFINITY);\n            const used = new Array(columns + 1).fill(false);\n            do {\n                used[column0] = true;\n                const row0 = p[column0];\n                let delta = Number.POSITIVE_INFINITY;\n                let column1 = 0;\n                for (let column = 1; column <= columns; column += 1) {\n                    if (used[column])\n                        continue;\n                    const current = costs[row0 - 1][column - 1] - u[row0] - v[column];\n                    if (current < minValue[column]) {\n                        minValue[column] = current;\n                        way[column] = column0;\n                    }\n                    if (minValue[column] < delta) {\n                        delta = minValue[column];\n                        column1 = column;\n                    }\n                }\n                for (let column = 0; column <= columns; column += 1) {\n                    if (used[column]) {\n                        u[p[column]] += delta;\n                        v[column] -= delta;\n                    }\n                    else {\n                        minValue[column] -= delta;\n                    }\n                }\n                column0 = column1;\n            } while (p[column0] !== 0);\n            do {\n                const column1 = way[column0];\n                p[column0] = p[column1];\n                column0 = column1;\n            } while (column0 !== 0);\n        }\n        const assignments = [];\n        for (let column = 1; column <= columns; column += 1) {\n            if (p[column] === 0)\n                continue;\n            const row = p[column] - 1;\n            assignments.push(transposed ? [column - 1, row] : [row, column - 1]);\n        }\n        return assignments;\n    }\n    function rectToXyxy(rect) {\n        return [\n            rect.x - rect.width / 2,\n            rect.y - rect.height / 2,\n            rect.x + rect.width / 2,\n            rect.y + rect.height / 2,\n        ];\n    }\n    function stateToRect(state) {\n        // The Python XYXY estimator intentionally leaves corner velocities\n        // unconstrained. Normalize only at the browser Rect boundary so a crossing\n        // prediction cannot violate the positive-width/height storage contract.\n        const x1 = Math.min(state[0][0], state[2][0]);\n        const y1 = Math.min(state[1][0], state[3][0]);\n        const x2 = Math.max(state[0][0], state[2][0]);\n        const y2 = Math.max(state[1][0], state[3][0]);\n        return {\n            height: Math.max(Number.EPSILON, y2 - y1),\n            width: Math.max(Number.EPSILON, x2 - x1),\n            x: (x1 + x2) / 2,\n            y: (y1 + y2) / 2,\n        };\n    }\n    function createProcessNoise(frameStep, frameRate) {\n        if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n            return scale(identity(8), 0.01);\n        }\n        const result = Array.from({ length: 8 }, () => new Array(8).fill(0));\n        const dt2 = frameStep * frameStep;\n        const dt3 = dt2 * frameStep;\n        const dt4 = dt2 * dt2;\n        for (let index = 0; index < 4; index += 1) {\n            const velocityIndex = index + 4;\n            result[index][index] = (0.01 * dt4) / 4;\n            result[index][velocityIndex] = (0.01 * dt3) / 2;\n            result[velocityIndex][index] = (0.01 * dt3) / 2;\n            result[velocityIndex][velocityIndex] = 0.01 * dt2;\n        }\n        return result;\n    }\n    function intersectionOverUnion(left, right) {\n        const leftX = left.x - left.width / 2;\n        const leftY = left.y - left.height / 2;\n        const rightX = right.x - right.width / 2;\n        const rightY = right.y - right.height / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + left.width, rightX + right.width) -\n            Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + left.height, rightY + right.height) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = left.width * left.height + right.width * right.height - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n    function resolveFrameStep(current, previous) {\n        if (current === undefined || previous === undefined)\n            return 1;\n        return Math.max(1, current - previous);\n    }\n    function normalizePositiveInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 1) {\n            throw new Error(`${label} must be a positive integer.`);\n        }\n        return value;\n    }\n    function normalizeNonNegativeInteger$1(value, label) {\n        if (!Number.isInteger(value) || value < 0) {\n            throw new Error(`${label} must be a non-negative integer.`);\n        }\n        return value;\n    }\n    function normalizeUnitInterval$1(value, label) {\n        if (!Number.isFinite(value) || value < 0 || value > 1) {\n            throw new Error(`${label} must be between 0 and 1.`);\n        }\n    }\n    function identity(size) {\n        return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));\n    }\n    function scale(matrix, factor) {\n        return matrix.map((row) => row.map((value) => value * factor));\n    }\n    function transpose(matrix) {\n        return matrix[0].map((_, column) => matrix.map((row) => row[column]));\n    }\n    function add(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value + right[rowIndex][columnIndex]));\n    }\n    function subtract(left, right) {\n        return left.map((row, rowIndex) => row.map((value, columnIndex) => value - right[rowIndex][columnIndex]));\n    }\n    function multiply(left, right) {\n        return left.map((row) => right[0].map((_, column) => row.reduce((sum, value, index) => sum + value * right[index][column], 0)));\n    }\n    function inverse(matrix) {\n        const size = matrix.length;\n        const augmented = matrix.map((row, index) => [\n            ...row,\n            ...identity(size)[index],\n        ]);\n        for (let column = 0; column < size; column += 1) {\n            let pivot = column;\n            for (let row = column + 1; row < size; row += 1) {\n                if (Math.abs(augmented[row][column]) >\n                    Math.abs(augmented[pivot][column])) {\n                    pivot = row;\n                }\n            }\n            if (Math.abs(augmented[pivot][column]) < 1e-12) {\n                throw new Error(\"SORT Kalman covariance is singular.\");\n            }\n            [augmented[column], augmented[pivot]] = [\n                augmented[pivot],\n                augmented[column],\n            ];\n            const divisor = augmented[column][column];\n            augmented[column] = augmented[column].map((value) => value / divisor);\n            for (let row = 0; row < size; row += 1) {\n                if (row === column)\n                    continue;\n                const factor = augmented[row][column];\n                augmented[row] = augmented[row].map((value, index) => value - factor * augmented[column][index]);\n            }\n        }\n        return augmented.map((row) => row.slice(size));\n    }\n\n    /**\n     * Creates one stateful ByteTrack tracker for a single ordered media sequence.\n     *\n     * Defaults and two-stage association mirror roboflow/trackers ByteTrack at\n     * source commit 60b21c8a48676784085fbee455559f16b75a7c9a.\n     * Motion predictions remain internal; only observed detections receive IDs.\n     */\n    function createByteTrackTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.1;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    if ((detection.confidence ?? 1) >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const assignments = new Map();\n                const firstStage = associate(tracks, detections, highDetectionIndexes, minimumIouThreshold);\n                for (const match of firstStage.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                const remainingTracks = firstStage.unmatchedTrackIndexes.map((index) => tracks[index]);\n                const secondStage = associate(remainingTracks, detections, lowDetectionIndexes, minimumIouThreshold);\n                for (const match of secondStage.matches) {\n                    updateMatchedTrack(remainingTracks[match.trackIndex], detections[match.detectionIndex], assignments);\n                }\n                // Only unmatched high-confidence observations can start a track.\n                for (const detectionIndex of firstStage.unmatchedDetectionIndexes) {\n                    const detection = detections[detectionIndex];\n                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {\n                        tracks.push(new KalmanBoxTrack(detection, true));\n                    }\n                }\n                // Confirmation is sticky once an ID has been allocated. An unmatched\n                // unconfirmed track is discarded immediately, as in Python ByteTrack.\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames ||\n                        track.timeSinceUpdate === 0));\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: detections.flatMap((detection) => {\n                        const trackerId = assignments.get(detection.detectionIndex);\n                        return trackerId === undefined\n                            ? []\n                            : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                    }),\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId;\n                nextTrackerId += 1;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function associate(tracks, detections, detectionIndexes, minimumIouThreshold) {\n        if (tracks.length === 0 || detectionIndexes.length === 0) {\n            return {\n                matches: [],\n                unmatchedDetectionIndexes: [...detectionIndexes],\n                unmatchedTrackIndexes: tracks.map((_, index) => index),\n            };\n        }\n        const scores = tracks.map((track) => {\n            const predictedRect = track.getStateRect();\n            return detectionIndexes.map((detectionIndex) => intersectionOverUnion(predictedRect, detections[detectionIndex].rect));\n        });\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, localDetectionIndex] of maximizeAssignment(scores)) {\n            if (scores[trackIndex][localDetectionIndex] < minimumIouThreshold) {\n                continue;\n            }\n            const detectionIndex = detectionIndexes[localDetectionIndex];\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: detectionIndexes.filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: tracks.flatMap((_, index) => matchedTracks.has(index) ? [] : [index]),\n        };\n    }\n\n    function associateTrackingScores(scores, trackCount, detectionCount, minimumScore, acceptanceScores = scores) {\n        const matches = [];\n        const matchedTracks = new Set();\n        const matchedDetections = new Set();\n        for (const [trackIndex, detectionIndex] of maximizeAssignment(scores)) {\n            if (acceptanceScores[trackIndex][detectionIndex] < minimumScore)\n                continue;\n            matches.push({ detectionIndex, trackIndex });\n            matchedTracks.add(trackIndex);\n            matchedDetections.add(detectionIndex);\n        }\n        matches.sort((left, right) => left.trackIndex - right.trackIndex);\n        return {\n            matches,\n            unmatchedDetectionIndexes: Array.from({ length: detectionCount }, (_, index) => index).filter((index) => !matchedDetections.has(index)),\n            unmatchedTrackIndexes: Array.from({ length: trackCount }, (_, index) => index).filter((index) => !matchedTracks.has(index)),\n        };\n    }\n    function pairwiseIou(tracks, detections, bufferRatio = 0) {\n        return tracks.map((track) => detections.map((detection) => bufferedIntersectionOverUnion(track, detection, bufferRatio)));\n    }\n    function bufferedIntersectionOverUnion(left, right, bufferRatio) {\n        const leftWidth = left.width * (1 + 2 * bufferRatio);\n        const leftHeight = left.height * (1 + 2 * bufferRatio);\n        const rightWidth = right.width * (1 + 2 * bufferRatio);\n        const rightHeight = right.height * (1 + 2 * bufferRatio);\n        const leftX = left.x - leftWidth / 2;\n        const leftY = left.y - leftHeight / 2;\n        const rightX = right.x - rightWidth / 2;\n        const rightY = right.y - rightHeight / 2;\n        const intersectionWidth = Math.max(0, Math.min(leftX + leftWidth, rightX + rightWidth) - Math.max(leftX, rightX));\n        const intersectionHeight = Math.max(0, Math.min(leftY + leftHeight, rightY + rightHeight) -\n            Math.max(leftY, rightY));\n        const intersection = intersectionWidth * intersectionHeight;\n        const union = leftWidth * leftHeight + rightWidth * rightHeight - intersection;\n        return union <= 0 ? 0 : intersection / union;\n    }\n\n    /**\n     * Kalman state estimator shared by the browser C-BIoU and OC-SORT ports.\n     * Its layouts, covariance update, and gap-scaled constant-velocity model\n     * mirror roboflow/trackers at 60b21c8.\n     */\n    class TrackingKalmanEstimator {\n        representation;\n        dimension;\n        measurementDimension = 4;\n        covariance;\n        measurementNoise = identity(4);\n        processNoise;\n        state;\n        baselineProcessNoise;\n        positionIndexes;\n        velocityIndexes;\n        constructor(initialRect, representation) {\n            this.representation = representation;\n            const measurement = rectToMeasurement(initialRect, representation);\n            this.dimension = representation === \"xcycsr\" ? 7 : 8;\n            this.positionIndexes =\n                representation === \"xcycsr\" ? [0, 1, 2] : [0, 1, 2, 3];\n            this.velocityIndexes =\n                representation === \"xcycsr\" ? [4, 5, 6] : [4, 5, 6, 7];\n            this.state = Array.from({ length: this.dimension }, (_, index) => [\n                measurement[index] ?? 0,\n            ]);\n            this.covariance = identity(this.dimension);\n            this.processNoise = identity(this.dimension);\n            this.baselineProcessNoise = identity(this.dimension);\n        }\n        predict(frameStep, frameRate) {\n            if (this.representation === \"xcycsr\" &&\n                this.state[2][0] + frameStep * this.state[6][0] <= 0) {\n                this.state[6][0] = 0;\n            }\n            const transition = identity(this.dimension);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                transition[positionIndex][this.velocityIndexes[index]] = frameStep;\n            });\n            this.processNoise = this.createProcessNoise(frameStep, frameRate);\n            this.state = multiply(transition, this.state);\n            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), this.processNoise);\n        }\n        update(rect) {\n            this.updateMeasurement(rectToMeasurement(rect, this.representation));\n        }\n        updateMeasurement(measurement) {\n            const observation = Array.from({ length: 4 }, (_, row) => Array.from({ length: this.dimension }, (_, column) => row === column ? 1 : 0));\n            const measurementColumn = measurement.map((value) => [value]);\n            const innovation = subtract(measurementColumn, multiply(observation, this.state));\n            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));\n            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), this.measurementNoise);\n            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));\n            this.state = add(this.state, multiply(gain, innovation));\n            const identityMinusGainObservation = subtract(identity(this.dimension), multiply(gain, observation));\n            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, this.measurementNoise), transpose(gain)));\n        }\n        getRect() {\n            return measurementToRect(this.state.slice(0, 4).map((row) => row[0]), this.representation);\n        }\n        setCovariances(options) {\n            if (options.covariance)\n                this.covariance = clone(options.covariance);\n            if (options.measurementNoise) {\n                this.measurementNoise = clone(options.measurementNoise);\n            }\n            if (options.processNoise) {\n                this.processNoise = clone(options.processNoise);\n                this.baselineProcessNoise = clone(options.processNoise);\n            }\n        }\n        snapshot() {\n            return {\n                covariance: clone(this.covariance),\n                measurementNoise: clone(this.measurementNoise),\n                processNoise: clone(this.processNoise),\n                state: clone(this.state),\n            };\n        }\n        restore(snapshot) {\n            this.covariance = clone(snapshot.covariance);\n            this.measurementNoise = clone(snapshot.measurementNoise);\n            this.processNoise = clone(snapshot.processNoise);\n            this.state = clone(snapshot.state);\n        }\n        createProcessNoise(frameStep, frameRate) {\n            if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {\n                return clone(this.baselineProcessNoise);\n            }\n            const result = Array.from({ length: this.dimension }, () => new Array(this.dimension).fill(0));\n            const dt2 = frameStep * frameStep;\n            const dt3 = dt2 * frameStep;\n            const dt4 = dt2 * dt2;\n            const kinematicIndexes = new Set([\n                ...this.positionIndexes,\n                ...this.velocityIndexes,\n            ]);\n            this.positionIndexes.forEach((positionIndex, index) => {\n                const velocityIndex = this.velocityIndexes[index];\n                const accelerationVariance = this.baselineProcessNoise[velocityIndex][velocityIndex];\n                result[positionIndex][positionIndex] = (accelerationVariance * dt4) / 4;\n                result[positionIndex][velocityIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][positionIndex] = (accelerationVariance * dt3) / 2;\n                result[velocityIndex][velocityIndex] = accelerationVariance * dt2;\n            });\n            for (let index = 0; index < this.dimension; index += 1) {\n                if (!kinematicIndexes.has(index)) {\n                    result[index][index] = this.baselineProcessNoise[index][index];\n                }\n            }\n            return result;\n        }\n    }\n    function rectToMeasurement(rect, representation) {\n        if (representation === \"xcycwh\") {\n            return [rect.x, rect.y, rect.width, rect.height];\n        }\n        return [\n            rect.x,\n            rect.y,\n            rect.width * rect.height,\n            rect.width / (rect.height + 1e-6),\n        ];\n    }\n    function measurementToRect(measurement, representation) {\n        const [x, y, third, fourth] = measurement;\n        if (representation === \"xcycwh\") {\n            return {\n                height: Math.max(1e-3, fourth),\n                width: Math.max(1e-3, third),\n                x,\n                y,\n            };\n        }\n        const width = Math.sqrt(third * fourth);\n        const height = width === 0 ? 0 : third / width;\n        return {\n            height: Math.max(Number.EPSILON, height),\n            width: Math.max(Number.EPSILON, width),\n            x,\n            y,\n        };\n    }\n    function diagonal(values) {\n        return values.map((value, row) => values.map((_, column) => (row === column ? value : 0)));\n    }\n    function scaleMatrix(matrix, factor) {\n        return scale(matrix, factor);\n    }\n    function clone(matrix) {\n        return matrix.map((row) => [...row]);\n    }\n\n    const MINIMUM_DETECTION_CONFIDENCE = 0.1;\n    class CBIoUTrack {\n        trackerId;\n        successfulUpdates = 1;\n        timeSinceUpdate = 0;\n        estimator;\n        constructor(initial) {\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycwh\");\n            this.setInitialNoise(initial.rect.width, initial.rect.height);\n        }\n        predict(frameStep, frameRate) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                processNoise: this.buildProcessNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.predict(frameStep, frameRate);\n            this.clampState();\n            this.timeSinceUpdate += 1;\n        }\n        update(detection) {\n            const current = this.estimator.getRect();\n            this.estimator.setCovariances({\n                measurementNoise: this.buildMeasurementNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),\n            });\n            this.estimator.update(detection.rect);\n            this.clampState();\n            this.timeSinceUpdate = 0;\n            this.successfulUpdates += 1;\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        setInitialNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            this.estimator.setCovariances({\n                covariance: diagonal([\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (2 * sigmaPosition * width) ** 2,\n                    (2 * sigmaPosition * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                    (10 * sigmaVelocity * width) ** 2,\n                    (10 * sigmaVelocity * height) ** 2,\n                ]),\n                measurementNoise: this.buildMeasurementNoise(width, height),\n                processNoise: this.buildProcessNoise(width, height),\n            });\n        }\n        buildProcessNoise(width, height) {\n            const sigmaPosition = 0.05;\n            const sigmaVelocity = 0.00625;\n            return diagonal([\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaPosition * width) ** 2,\n                (sigmaPosition * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n                (sigmaVelocity * width) ** 2,\n                (sigmaVelocity * height) ** 2,\n            ]);\n        }\n        buildMeasurementNoise(width, height) {\n            const sigmaMeasurement = 0.05;\n            return diagonal([\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n                (sigmaMeasurement * width) ** 2,\n                (sigmaMeasurement * height) ** 2,\n            ]);\n        }\n        clampState() {\n            this.estimator.state[2][0] = Math.max(this.estimator.state[2][0], 1e-3);\n            this.estimator.state[3][0] = Math.max(this.estimator.state[3][0], 1e-3);\n        }\n    }\n    /** Creates the detection-only C-BIoU implementation from roboflow/trackers. */\n    function createCBIoUTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, \"minimumConsecutiveFrames\");\n        const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ?? 0.2;\n        const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ?? 0.5;\n        const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ?? 0.3;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const instantFirstFrameActivation = options.instantFirstFrameActivation ?? true;\n        const bufferRatioFirst = options.bufferRatioFirst ?? 0.3;\n        const bufferRatioSecond = options.bufferRatioSecond ?? 0.5;\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(trackActivationThreshold, \"trackActivationThreshold\");\n        normalizeUnitInterval$1(minimumIouThresholdFirstAssociation, \"minimumIouThresholdFirstAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdSecondAssociation, \"minimumIouThresholdSecondAssociation\");\n        normalizeUnitInterval$1(minimumIouThresholdUnconfirmedAssociation, \"minimumIouThresholdUnconfirmedAssociation\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        if (!Number.isFinite(bufferRatioFirst) || bufferRatioFirst < 0) {\n            throw new Error(\"bufferRatioFirst must be a finite non-negative value.\");\n        }\n        if (!Number.isFinite(bufferRatioSecond) || bufferRatioSecond < 0) {\n            throw new Error(\"bufferRatioSecond must be a finite non-negative value.\");\n        }\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let nextTrackerId = 0;\n        let frameId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                nextTrackerId = 0;\n                frameId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                frameId += 1;\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = [];\n                const lowDetectionIndexes = [];\n                detections.forEach((detection, index) => {\n                    const confidence = detection.confidence ?? 1;\n                    if (confidence >= highConfidenceDetectionThreshold) {\n                        highDetectionIndexes.push(index);\n                    }\n                    else if (confidence > MINIMUM_DETECTION_CONFIDENCE) {\n                        lowDetectionIndexes.push(index);\n                    }\n                });\n                const confirmed = [];\n                const unconfirmed = [];\n                const lost = [];\n                for (const track of tracks) {\n                    if (track.timeSinceUpdate > 1)\n                        lost.push(track);\n                    else if (track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames) {\n                        confirmed.push(track);\n                    }\n                    else\n                        unconfirmed.push(track);\n                }\n                const assignments = new Map();\n                const pool = [...confirmed, ...lost];\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const firstScores = pairwiseIou(pool.map((track) => track.getRect()), highDetections.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (highDetections[index].confidence ?? 1)));\n                const firstAssociation = associateTrackingScores(firstScores, pool.length, highDetections.length, minimumIouThresholdFirstAssociation);\n                for (const match of firstAssociation.matches) {\n                    updateMatchedTrack(pool[match.trackIndex], highDetections[match.detectionIndex], assignments);\n                }\n                const remainingTracked = firstAssociation.unmatchedTrackIndexes\n                    .map((index) => pool[index])\n                    .filter((track) => track.timeSinceUpdate === 1);\n                const lowDetections = lowDetectionIndexes.map((index) => detections[index]);\n                const secondScores = pairwiseIou(remainingTracked.map((track) => track.getRect()), lowDetections.map((detection) => detection.rect), bufferRatioSecond);\n                const secondAssociation = associateTrackingScores(secondScores, remainingTracked.length, lowDetections.length, minimumIouThresholdSecondAssociation);\n                for (const match of secondAssociation.matches) {\n                    updateMatchedTrack(remainingTracked[match.trackIndex], lowDetections[match.detectionIndex], assignments);\n                }\n                let unmatchedHighLocal = [...firstAssociation.unmatchedDetectionIndexes];\n                let unmatchedUnconfirmed = unconfirmed.map((_, index) => index);\n                if (unconfirmed.length > 0 && unmatchedHighLocal.length > 0) {\n                    const remainingHigh = unmatchedHighLocal.map((index) => highDetections[index]);\n                    const unconfirmedScores = pairwiseIou(unconfirmed.map((track) => track.getRect()), remainingHigh.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (remainingHigh[index].confidence ?? 1)));\n                    const unconfirmedAssociation = associateTrackingScores(unconfirmedScores, unconfirmed.length, remainingHigh.length, minimumIouThresholdUnconfirmedAssociation);\n                    unmatchedUnconfirmed = unconfirmedAssociation.unmatchedTrackIndexes;\n                    for (const match of unconfirmedAssociation.matches) {\n                        updateMatchedTrack(unconfirmed[match.trackIndex], remainingHigh[match.detectionIndex], assignments);\n                    }\n                    unmatchedHighLocal =\n                        unconfirmedAssociation.unmatchedDetectionIndexes.map((index) => unmatchedHighLocal[index]);\n                }\n                const unmatchedUnconfirmedTracks = new Set(unmatchedUnconfirmed.map((index) => unconfirmed[index]));\n                tracks = tracks.filter((track) => !unmatchedUnconfirmedTracks.has(track));\n                for (const localIndex of unmatchedHighLocal) {\n                    const detection = highDetections[localIndex];\n                    if ((detection.confidence ?? 1) < trackActivationThreshold)\n                        continue;\n                    const track = new CBIoUTrack(detection);\n                    if (frameId === 1 && instantFirstFrameActivation) {\n                        track.trackerId = nextTrackerId++;\n                        assignments.set(detection.detectionIndex, track.trackerId);\n                    }\n                    tracks.push(track);\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&\n                    (track.timeSinceUpdate === 0 ||\n                        track.trackerId !== undefined ||\n                        track.successfulUpdates >= minimumConsecutiveFrames));\n                return createUpdate(detections, assignments, tracks);\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments) {\n            track.update(detection);\n            if (track.trackerId === undefined &&\n                track.successfulUpdates >= minimumConsecutiveFrames) {\n                track.trackerId = nextTrackerId++;\n            }\n            if (track.trackerId !== undefined) {\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function createUpdate(detections, assignments, tracks) {\n        const resolvedAssignments = detections.flatMap((detection) => {\n            const trackerId = assignments.get(detection.detectionIndex);\n            return trackerId === undefined\n                ? []\n                : [{ detectionIndex: detection.detectionIndex, trackerId }];\n        });\n        return {\n            activeTrackCount: tracks.length,\n            assignments: resolvedAssignments,\n            confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined)\n                .length,\n        };\n    }\n\n    class OCSortTrack {\n        deltaT;\n        age = 0;\n        lastObservation;\n        trackerId;\n        successfulConsecutiveUpdates = 0;\n        timeSinceUpdate = 0;\n        velocity;\n        frozenState;\n        observed = true;\n        observations = new Map();\n        estimator;\n        constructor(initial, deltaT) {\n            this.deltaT = deltaT;\n            this.lastObservation = initial;\n            this.estimator = new TrackingKalmanEstimator(initial.rect, \"xcycsr\");\n            this.configureNoise();\n        }\n        predict(frameStep, frameRate) {\n            if (this.observed && this.timeSinceUpdate > 0) {\n                this.frozenState = this.estimator.snapshot();\n                this.observed = false;\n            }\n            this.estimator.predict(frameStep, frameRate);\n            if (this.timeSinceUpdate > 0) {\n                this.successfulConsecutiveUpdates = 0;\n            }\n            this.timeSinceUpdate += 1;\n            this.age += 1;\n        }\n        update(detection, frameStep, frameRate) {\n            const previous = this.getPreviousObservation();\n            if (previous) {\n                this.velocity = computeVelocity(previous, detection);\n            }\n            if (!this.observed && this.frozenState) {\n                this.unfreeze(detection, frameStep, frameRate);\n            }\n            this.estimator.update(detection.rect);\n            this.observed = true;\n            this.timeSinceUpdate = 0;\n            this.successfulConsecutiveUpdates += 1;\n            this.lastObservation = detection;\n            this.observations.set(this.age, detection);\n            const cutoff = this.age - this.deltaT;\n            for (const age of this.observations.keys()) {\n                if (age < cutoff)\n                    this.observations.delete(age);\n            }\n        }\n        getRect() {\n            return this.estimator.getRect();\n        }\n        getPreviousObservation() {\n            if (this.observations.size === 0)\n                return undefined;\n            for (let index = 0; index < this.deltaT; index += 1) {\n                const delta = this.deltaT - index;\n                const observation = this.observations.get(this.age - delta);\n                if (observation)\n                    return observation;\n            }\n            const latestAge = Math.max(...this.observations.keys());\n            return this.observations.get(latestAge);\n        }\n        configureNoise() {\n            const measurementNoise = identity(4);\n            for (let index = 2; index < 4; index += 1) {\n                measurementNoise[index][index] *= 10;\n            }\n            const covariance = scaleMatrix(identity(7), 10);\n            for (let index = 4; index < 7; index += 1) {\n                covariance[index][index] *= 1000;\n            }\n            const processNoise = identity(7);\n            processNoise[6][6] *= 0.01;\n            for (let index = 4; index < 7; index += 1) {\n                processNoise[index][index] *= 0.01;\n            }\n            this.estimator.setCovariances({\n                covariance,\n                measurementNoise,\n                processNoise,\n            });\n        }\n        unfreeze(detection, frameStep, frameRate) {\n            if (!this.frozenState || this.timeSinceUpdate === 0)\n                return;\n            this.estimator.restore(this.frozenState);\n            const timeGap = this.timeSinceUpdate;\n            const start = rectToMeasurement(this.lastObservation.rect, \"xcycsr\");\n            const end = rectToMeasurement(detection.rect, \"xcycsr\");\n            const startWidth = Math.sqrt(start[2] * start[3]);\n            const startHeight = start[3] === 0 ? 0 : Math.sqrt(start[2] / start[3]);\n            const endWidth = Math.sqrt(end[2] * end[3]);\n            const endHeight = end[3] === 0 ? 0 : Math.sqrt(end[2] / end[3]);\n            for (let index = 0; index < timeGap; index += 1) {\n                const progress = (index + 1) / timeGap;\n                const x = start[0] + progress * (end[0] - start[0]);\n                const y = start[1] + progress * (end[1] - start[1]);\n                const width = startWidth + progress * (endWidth - startWidth);\n                const height = startHeight + progress * (endHeight - startHeight);\n                this.estimator.updateMeasurement([x, y, width * height, width / height]);\n                if (index < timeGap - 1) {\n                    this.estimator.predict(frameStep, frameRate);\n                }\n            }\n            this.frozenState = undefined;\n        }\n    }\n    /** Creates the observation-centric SORT implementation from roboflow/trackers. */\n    function createOCSortTracker$1(options = {}) {\n        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, \"lostTrackBuffer\");\n        const frameRate = options.frameRate ?? 30;\n        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, \"minimumConsecutiveFrames\");\n        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;\n        const directionConsistencyWeight = options.directionConsistencyWeight ?? 0.2;\n        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;\n        const deltaT = normalizePositiveInteger$1(options.deltaT ?? 3, \"deltaT\");\n        if (!Number.isFinite(frameRate) || frameRate <= 0) {\n            throw new Error(\"frameRate must be a finite positive value.\");\n        }\n        normalizeUnitInterval$1(minimumIouThreshold, \"minimumIouThreshold\");\n        normalizeUnitInterval$1(directionConsistencyWeight, \"directionConsistencyWeight\");\n        normalizeUnitInterval$1(highConfidenceDetectionThreshold, \"highConfidenceDetectionThreshold\");\n        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;\n        if (!Number.isFinite(scaledLostTrackBuffer)) {\n            throw new Error(\"Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.\");\n        }\n        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));\n        let tracks = [];\n        let frameCount = 0;\n        let nextTrackerId = 0;\n        let previousFrameIndex;\n        return {\n            reset() {\n                tracks = [];\n                frameCount = 0;\n                nextTrackerId = 0;\n                previousFrameIndex = undefined;\n            },\n            update(detections, frameIndex) {\n                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);\n                previousFrameIndex = frameIndex ?? previousFrameIndex;\n                // Match roboflow/trackers: an empty stream before any track exists is\n                // not part of OC-SORT's early-sequence activation window.\n                if (tracks.length === 0 && detections.length === 0) {\n                    return {\n                        activeTrackCount: 0,\n                        assignments: [],\n                        confirmedTrackCount: 0,\n                    };\n                }\n                tracks.forEach((track) => track.predict(frameStep, frameRate));\n                const highDetectionIndexes = detections.flatMap((detection, index) => detection.confidence === undefined ||\n                    detection.confidence >= highConfidenceDetectionThreshold\n                    ? [index]\n                    : []);\n                const highDetections = highDetectionIndexes.map((index) => detections[index]);\n                const iouScores = pairwiseIou(tracks.map((track) => track.getRect()), highDetections.map((detection) => detection.rect));\n                const combinedScores = iouScores.map((row, trackIndex) => row.map((iou, detectionIndex) => {\n                    if (directionConsistencyWeight === 0)\n                        return iou;\n                    return (iou +\n                        directionConsistencyWeight *\n                            directionConsistency(tracks[trackIndex], highDetections[detectionIndex]) *\n                            (highDetections[detectionIndex].confidence ?? 1));\n                }));\n                const primary = associateTrackingScores(combinedScores, tracks.length, highDetections.length, minimumIouThreshold, iouScores);\n                const assignments = new Map();\n                for (const match of primary.matches) {\n                    updateMatchedTrack(tracks[match.trackIndex], highDetections[match.detectionIndex], assignments, frameStep);\n                }\n                let remainingHigh = [...primary.unmatchedDetectionIndexes];\n                if (primary.unmatchedTrackIndexes.length > 0 &&\n                    remainingHigh.length > 0) {\n                    const unmatchedTracks = primary.unmatchedTrackIndexes.map((index) => tracks[index]);\n                    const unmatchedDetections = remainingHigh.map((index) => highDetections[index]);\n                    const recoveryScores = pairwiseIou(unmatchedTracks.map((track) => track.lastObservation.rect), unmatchedDetections.map((detection) => detection.rect));\n                    const recovery = associateTrackingScores(recoveryScores, unmatchedTracks.length, unmatchedDetections.length, minimumIouThreshold);\n                    for (const match of recovery.matches) {\n                        updateMatchedTrack(unmatchedTracks[match.trackIndex], unmatchedDetections[match.detectionIndex], assignments, frameStep);\n                    }\n                    remainingHigh = recovery.unmatchedDetectionIndexes.map((index) => remainingHigh[index]);\n                }\n                for (const localIndex of remainingHigh) {\n                    tracks.push(new OCSortTrack(highDetections[localIndex], deltaT));\n                }\n                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate);\n                frameCount += 1;\n                const resolvedAssignments = detections.flatMap((detection) => {\n                    const trackerId = assignments.get(detection.detectionIndex);\n                    return trackerId === undefined\n                        ? []\n                        : [{ detectionIndex: detection.detectionIndex, trackerId }];\n                });\n                return {\n                    activeTrackCount: tracks.length,\n                    assignments: resolvedAssignments,\n                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,\n                };\n            },\n        };\n        function updateMatchedTrack(track, detection, assignments, frameStep) {\n            track.update(detection, frameStep, frameRate);\n            const earlySequence = frameCount <= minimumConsecutiveFrames;\n            const shouldEmit = (earlySequence && track.timeSinceUpdate === 0) ||\n                track.successfulConsecutiveUpdates >= minimumConsecutiveFrames;\n            if (shouldEmit) {\n                if (track.trackerId === undefined) {\n                    track.trackerId = nextTrackerId++;\n                }\n                assignments.set(detection.detectionIndex, track.trackerId);\n            }\n        }\n    }\n    function computeVelocity(previous, current) {\n        const deltaX = current.rect.x - previous.rect.x;\n        const deltaY = current.rect.y - previous.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        return { x: deltaX / norm, y: deltaY / norm };\n    }\n    function directionConsistency(track, detection) {\n        if (!track.velocity)\n            return 0;\n        const reference = track.getPreviousObservation() ?? track.lastObservation;\n        const deltaX = detection.rect.x - reference.rect.x;\n        const deltaY = detection.rect.y - reference.rect.y;\n        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;\n        const cosine = Math.max(-1, Math.min(1, track.velocity.x * (deltaX / norm) + track.velocity.y * (deltaY / norm)));\n        const angle = Math.acos(cosine);\n        return (Math.PI / 2 - Math.abs(angle)) / Math.PI;\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createSortTracker(options = {}) {\n        return createSortTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createByteTrackTracker(options = {}) {\n        return createByteTrackTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createCBIoUTracker(options = {}) {\n        return createCBIoUTracker$1(options);\n    }\n\n    /** Public core facade for the internal tracker engine workspace. */\n    function createOCSortTracker(options = {}) {\n        return createOCSortTracker$1(options);\n    }\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    let tracker;\n    self.addEventListener(\"message\", (event) => {\n        const request = event.data;\n        try {\n            let response;\n            if (request.type === \"configure\") {\n                switch (request.processor.algorithm) {\n                    case \"bytetrack\":\n                        tracker = createByteTrackTracker(request.processor.options);\n                        break;\n                    case \"cbiou\":\n                        tracker = createCBIoUTracker(request.processor.options);\n                        break;\n                    case \"ocsort\":\n                        tracker = createOCSortTracker(request.processor.options);\n                        break;\n                    default:\n                        tracker = createSortTracker(request.processor.options);\n                }\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else if (request.type === \"reset\") {\n                tracker?.reset();\n                response = { requestId: request.requestId, type: \"success\" };\n            }\n            else {\n                if (!tracker) {\n                    throw new Error(\"Tracking worker is not configured.\");\n                }\n                const startedAt = performance.now();\n                const update = tracker.update(request.detections, request.frameIndex);\n                response = {\n                    ...update,\n                    durationMs: performance.now() - startedAt,\n                    requestId: request.requestId,\n                    type: \"success\",\n                };\n            }\n            self.postMessage(response);\n        }\n        catch (error) {\n            self.postMessage({\n                message: error instanceof Error ? error.message : \"Tracking worker failed.\",\n                requestId: request.requestId,\n                type: \"error\",\n            });\n        }\n    });\n\n})();";
+
+const DEFAULT_WORKER_NAME$1 = "supervision-detection-post-processing";
+let defaultWorkerUrl$1;
+function createDefaultDetectionPostProcessingWorkerFactory() {
+    return {
+        createWorker() {
+            defaultWorkerUrl$1 ??= URL.createObjectURL(new Blob([EMBEDDED_TRACKING_WORKER_SOURCE], {
+                type: "text/javascript",
+            }));
+            return new Worker(defaultWorkerUrl$1, { name: DEFAULT_WORKER_NAME$1 });
+        },
+    };
+}
+
+function isTrackingWorkerResponse(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.requestId === "number" &&
+        (candidate.type === "success" ||
+            (candidate.type === "error" && typeof candidate.message === "string")));
+}
+
+var DetectionPostProcessingMode;
+(function (DetectionPostProcessingMode) {
+    DetectionPostProcessingMode["Auto"] = "auto";
+    DetectionPostProcessingMode["Worker"] = "worker";
+    DetectionPostProcessingMode["MainThread"] = "mainThread";
+})(DetectionPostProcessingMode || (DetectionPostProcessingMode = {}));
+
+function createWorkerRpcClient(options) {
+    let failureMessage = null;
+    let isDestroyed = false;
+    let nextRequestId = 1;
+    const pendingRequests = new Map();
+    options.worker.addEventListener("message", (event) => {
+        handleWorkerMessage(event.data);
+    });
+    options.worker.addEventListener("error", (event) => {
+        rejectPendingRequests(event.message || options.defaultErrorMessage);
+    });
+    options.worker.addEventListener("messageerror", () => {
+        rejectPendingRequests(`${options.defaultErrorMessage}: message error.`);
+    });
+    return {
+        destroy() {
+            if (isDestroyed) {
+                return;
+            }
+            isDestroyed = true;
+            rejectPendingRequests("Worker RPC client has been destroyed.", {
+                markFailure: false,
+            });
+            options.worker.terminate();
+        },
+        getFailureMessage() {
+            return failureMessage;
+        },
+        request(message) {
+            if (isDestroyed) {
+                return Promise.reject(new Error("Worker RPC client has been destroyed."));
+            }
+            if (failureMessage) {
+                return Promise.reject(new Error(failureMessage));
+            }
+            const request = {
+                ...message,
+                requestId: nextRequestId,
+            };
+            nextRequestId += 1;
+            return new Promise((resolve, reject) => {
+                pendingRequests.set(request.requestId, { reject, resolve });
+                try {
+                    options.worker.postMessage(request);
+                }
+                catch (error) {
+                    pendingRequests.delete(request.requestId);
+                    failureMessage = getErrorMessage$2(error, options.defaultErrorMessage);
+                    reject(new Error(failureMessage));
+                }
+            });
+        },
+    };
+    function handleWorkerMessage(message) {
+        if (!options.isResponse(message)) {
+            return;
+        }
+        const pendingRequest = pendingRequests.get(message.requestId);
+        if (!pendingRequest) {
+            options.onOrphanedResponse?.(message);
+            return;
+        }
+        pendingRequests.delete(message.requestId);
+        pendingRequest.resolve(message);
+    }
+    function rejectPendingRequests(message, options = { markFailure: true }) {
+        if (options.markFailure) {
+            failureMessage = message;
+        }
+        for (const pendingRequest of pendingRequests.values()) {
+            pendingRequest.reject(new Error(message));
+        }
+        pendingRequests.clear();
+    }
+}
+function getErrorMessage$2(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+
+const DEFAULT_MAX_PENDING_FRAMES = 90;
+/**
+ * Creates an ordered, bounded stream processor for detections arriving out of
+ * order. Stateful processors run serially; the renderer remains independent.
+ */
+function createDetectionPostProcessingPipeline(options) {
+    const processor = validateProcessors(options.processors);
+    const maxPendingFrames = normalizePositiveInteger(options.maxPendingFrames ?? DEFAULT_MAX_PENDING_FRAMES, "maxPendingFrames");
+    let nextFrameIndex = normalizeFrameIndex(options.startFrameIndex ?? 0, "startFrameIndex");
+    let execution;
+    let destroyed = false;
+    let failedError;
+    let inFlightFrameIndex;
+    let processing = Promise.resolve({
+        acceptedFrameCount: 0,
+        processedFrameCount: 0,
+        processedFrames: [],
+    });
+    const pendingFrames = new Map();
+    let diagnostics = {
+        activeTrackCount: 0,
+        confirmedTrackCount: 0,
+        errorMessage: null,
+        executionMode: null,
+        lastFrameDurationMs: null,
+        nextFrameIndex,
+        pendingFrameCount: 0,
+        processedFrameCount: 0,
+        trackedDetectionCount: 0,
+    };
+    publishDiagnostics();
+    return {
+        async appendFrames(frames) {
+            assertActive();
+            assertHealthy();
+            const acceptedFrameCount = enqueueFrames(frames);
+            processing = processing.then(() => drainPendingFrames(acceptedFrameCount));
+            return processing;
+        },
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            pendingFrames.clear();
+            execution?.destroy();
+            execution = undefined;
+        },
+        getDiagnostics() {
+            return { ...diagnostics };
+        },
+        async reset(resetOptions = {}) {
+            assertActive();
+            await processing.catch(() => undefined);
+            pendingFrames.clear();
+            inFlightFrameIndex = undefined;
+            nextFrameIndex = normalizeFrameIndex(resetOptions.startFrameIndex ?? options.startFrameIndex ?? 0, "startFrameIndex");
+            await execution?.reset();
+            failedError = undefined;
+            processing = Promise.resolve({
+                acceptedFrameCount: 0,
+                processedFrameCount: 0,
+                processedFrames: [],
+            });
+            diagnostics = {
+                ...diagnostics,
+                activeTrackCount: 0,
+                confirmedTrackCount: 0,
+                errorMessage: null,
+                lastFrameDurationMs: null,
+                nextFrameIndex,
+                pendingFrameCount: 0,
+                processedFrameCount: 0,
+                trackedDetectionCount: 0,
+            };
+            publishDiagnostics();
+        },
+    };
+    function enqueueFrames(frames) {
+        let acceptedFrameCount = 0;
+        const additions = new Map();
+        for (const frame of frames) {
+            const frameIndex = normalizeFrameIndex(frame.frameIndex, "frameIndex");
+            if (frameIndex < nextFrameIndex) {
+                throw new Error(`Frame ${frameIndex} is behind the processed frontier ${nextFrameIndex}. Reset before revising causal history.`);
+            }
+            if (frameIndex === inFlightFrameIndex) {
+                throw new Error(`Frame ${frameIndex} is already being processed. Reset before revising causal history.`);
+            }
+            if (!pendingFrames.has(frameIndex) && !additions.has(frameIndex)) {
+                acceptedFrameCount += 1;
+            }
+            additions.set(frameIndex, frame);
+        }
+        const nextPendingCount = pendingFrames.size + acceptedFrameCount;
+        if (nextPendingCount > maxPendingFrames) {
+            throw new Error(`Out-of-order buffer limit exceeded (${nextPendingCount}/${maxPendingFrames}). Apply upstream backpressure or increase maxPendingFrames.`);
+        }
+        for (const [frameIndex, frame] of additions) {
+            pendingFrames.set(frameIndex, frame);
+        }
+        diagnostics = {
+            ...diagnostics,
+            nextFrameIndex,
+            pendingFrameCount: pendingFrames.size,
+        };
+        publishDiagnostics();
+        return acceptedFrameCount;
+    }
+    async function drainPendingFrames(acceptedFrameCount) {
+        const processedFrames = [];
+        try {
+            execution ??= await createTrackingExecution(processor, options);
+            diagnostics = { ...diagnostics, executionMode: execution.mode };
+            while (!destroyed) {
+                const frame = pendingFrames.get(nextFrameIndex);
+                if (!frame)
+                    break;
+                pendingFrames.delete(nextFrameIndex);
+                inFlightFrameIndex = nextFrameIndex;
+                const projections = projectDetectionFrameForTracking(frame, processor.geometry);
+                const result = await execution.process(projections, nextFrameIndex);
+                const processedFrame = attachTrackerIds(frame, result.assignments, options.mutateInput ?? true);
+                if (destroyed)
+                    break;
+                await options.output?.appendFrames([processedFrame]);
+                options.onFrame?.(processedFrame);
+                processedFrames.push(processedFrame);
+                nextFrameIndex += 1;
+                inFlightFrameIndex = undefined;
+                diagnostics = {
+                    ...diagnostics,
+                    activeTrackCount: result.activeTrackCount,
+                    confirmedTrackCount: result.confirmedTrackCount,
+                    errorMessage: null,
+                    lastFrameDurationMs: result.durationMs,
+                    nextFrameIndex,
+                    pendingFrameCount: pendingFrames.size,
+                    processedFrameCount: diagnostics.processedFrameCount + 1,
+                    trackedDetectionCount: diagnostics.trackedDetectionCount + result.assignments.length,
+                };
+                publishDiagnostics();
+            }
+            return {
+                acceptedFrameCount,
+                processedFrameCount: processedFrames.length,
+                processedFrames,
+            };
+        }
+        catch (error) {
+            failedError =
+                error instanceof Error ? error : new Error("Post-processing failed.");
+            diagnostics = {
+                ...diagnostics,
+                errorMessage: failedError.message,
+                pendingFrameCount: pendingFrames.size,
+            };
+            publishDiagnostics();
+            throw failedError;
+        }
+    }
+    function publishDiagnostics() {
+        options.onDiagnostics?.({ ...diagnostics });
+    }
+    function assertActive() {
+        if (destroyed) {
+            throw new Error("Detection post-processing pipeline has been destroyed.");
+        }
+    }
+    function assertHealthy() {
+        if (failedError) {
+            throw new Error(`Detection post-processing pipeline failed and must be reset: ${failedError.message}`);
+        }
+    }
+}
+async function createTrackingExecution(processor, options) {
+    const mode = options.mode ?? DetectionPostProcessingMode.Auto;
+    if (mode === DetectionPostProcessingMode.MainThread) {
+        return createMainThreadExecution(processor);
+    }
+    let workerExecution;
+    try {
+        const workerFactory = options.workerFactory ??
+            createDefaultDetectionPostProcessingWorkerFactory();
+        workerExecution = createWorkerExecution(workerFactory.createWorker(), processor);
+        await workerExecution.reset();
+        return workerExecution;
+    }
+    catch (error) {
+        workerExecution?.destroy();
+        if (mode === DetectionPostProcessingMode.Worker)
+            throw error;
+        return createMainThreadExecution(processor);
+    }
+}
+function createMainThreadExecution(processor) {
+    let tracker;
+    switch (processor.algorithm) {
+        case "bytetrack":
+            tracker = createByteTrackTracker(processor.options);
+            break;
+        case "cbiou":
+            tracker = createCBIoUTracker(processor.options);
+            break;
+        case "ocsort":
+            tracker = createOCSortTracker(processor.options);
+            break;
+        default:
+            tracker = createSortTracker(processor.options);
+    }
+    return {
+        destroy() { },
+        mode: "mainThread",
+        async process(detections, frameIndex) {
+            const startedAt = performance.now();
+            const update = tracker.update(detections, frameIndex);
+            return { ...update, durationMs: performance.now() - startedAt };
+        },
+        async reset() {
+            tracker.reset();
+        },
+    };
+}
+function createWorkerExecution(worker, processor) {
+    const client = createWorkerRpcClient({
+        defaultErrorMessage: "Detection post-processing worker failed.",
+        isResponse: isTrackingWorkerResponse,
+        worker,
+    });
+    let configured = false;
+    const request = async (message) => {
+        const response = await client.request(message);
+        if (response.type === "error")
+            throw new Error(response.message);
+        return response;
+    };
+    return {
+        destroy() {
+            client.destroy();
+        },
+        mode: "worker",
+        async process(detections, frameIndex) {
+            if (!configured) {
+                await request({ processor, type: "configure" });
+                configured = true;
+            }
+            const response = await request({
+                detections,
+                frameIndex,
+                type: "process",
+            });
+            return {
+                activeTrackCount: response.activeTrackCount ?? 0,
+                assignments: response.assignments ?? [],
+                confirmedTrackCount: response.confirmedTrackCount ?? 0,
+                durationMs: response.durationMs ?? 0,
+            };
+        },
+        async reset() {
+            if (!configured) {
+                await request({ processor, type: "configure" });
+                configured = true;
+            }
+            else {
+                await request({ type: "reset" });
+            }
+        },
+    };
+}
+function attachTrackerIds(frame, assignments, mutateInput) {
+    const trackerIds = new Map(assignments.map(({ detectionIndex, trackerId }) => [
+        detectionIndex,
+        trackerId,
+    ]));
+    for (const [detectionIndex, detection] of frame.detections.entries()) {
+        if (mutateInput) {
+            const trackerId = trackerIds.get(detectionIndex);
+            if (trackerId === undefined) {
+                Reflect.deleteProperty(detection, "trackerId");
+            }
+            else {
+                detection.trackerId = trackerId;
+            }
+        }
+    }
+    if (mutateInput) {
+        return frame;
+    }
+    return {
+        ...frame,
+        detections: frame.detections.map((detection, detectionIndex) => {
+            const semanticDetection = { ...detection };
+            Reflect.deleteProperty(semanticDetection, "trackerId");
+            const trackerId = trackerIds.get(detectionIndex);
+            return trackerId === undefined
+                ? semanticDetection
+                : { ...semanticDetection, trackerId };
+        }),
+    };
+}
+function validateProcessors(processors) {
+    if (processors.length !== 1 || processors[0]?.kind !== "tracking") {
+        throw new Error("The first post-processing release requires exactly one tracking processor.");
+    }
+    return processors[0];
+}
+function normalizePositiveInteger(value, label) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return value;
+}
+function normalizeFrameIndex(value, label) {
+    if (!Number.isInteger(value) || value === undefined || value < 0) {
+        throw new Error(`${label} must be a non-negative integer.`);
+    }
+    return value;
+}
+
 async function collectInputMetadata(input, source) {
     const [format, detectedMimeType, duration, primaryVideoTrack] = await Promise.all([
         input.getFormat(),
@@ -2239,11 +2667,15 @@ async function createMediaRendererCore(options, providers) {
         annotationOverlayStyle: options.annotationOverlayStyle,
         backgroundColor: options.backgroundColor,
         boxStyle: options.boxStyle,
+        boxCornerStyle: options.boxCornerStyle,
+        ellipseStyle: options.ellipseStyle,
         focusStyle: options.focusStyle,
         interactionStyle: options.interactionStyle,
         keypointStyle: options.keypointStyle,
         labelStyle: options.labelStyle,
+        maskHaloStyle: options.maskHaloStyle,
         maskStyle: options.maskStyle,
+        markerStyle: options.markerStyle,
         polygonStyle: options.polygonStyle,
         polylineStyle: options.polylineStyle,
         renderers: options.renderers,
@@ -2538,6 +2970,8 @@ async function createMediaRendererCore(options, providers) {
             annotationOverlayStyle: currentPresentation.annotationOverlayStyle,
             backgroundColor: currentPresentation.backgroundColor,
             boxStyle: currentPresentation.boxStyle,
+            boxCornerStyle: currentPresentation.boxCornerStyle,
+            ellipseStyle: currentPresentation.ellipseStyle,
             canInteract: () => canInteract(options, runtimeState.isPlaybackActive()),
             container: options.container,
             detectionTimeline,
@@ -2550,10 +2984,18 @@ async function createMediaRendererCore(options, providers) {
             keypointStyle: currentPresentation.keypointStyle,
             labelStyle: currentPresentation.labelStyle,
             maskBrush: options.createMaskBrush?.(mediaDimensions) ?? options.maskBrush,
+            maskHaloStyle: currentPresentation.maskHaloStyle,
             maskStyle: currentPresentation.maskStyle,
+            markerStyle: currentPresentation.markerStyle,
             maxDevicePixelRatio: options.maxDevicePixelRatio,
+            onPresentationUpdate(presentedSample) {
+                if (!runtimeState.isDestroyed()) {
+                    runtimeState.recordPresentationUpdate(presentedSample);
+                }
+            },
             polygonStyle: currentPresentation.polygonStyle,
             polylineStyle: currentPresentation.polylineStyle,
+            regionRenderers: resolveRegionRenderers(currentPresentation),
             previewOverlay: options.previewOverlay,
             renderPreparation: options.renderPreparation
                 ? {
@@ -2699,6 +3141,10 @@ async function createMediaRendererCore(options, providers) {
         }
     }
 }
+function resolveRegionRenderers(presentation) {
+    return (presentation.renderers?.filter((renderer) => renderer.kind === "region") ??
+        []);
+}
 async function openRendererMediaSource(options, providers) {
     if (options.src !== undefined && options.source !== undefined) {
         throw new Error("Provide either src or source, not both.");
@@ -2792,10 +3238,10 @@ function drawPixiPath(graphics, points, closed, stroke, viewportScale) {
     if (points.length < 2) {
         return;
     }
-    if (stroke.dash?.length) {
-        appendDashedPath(graphics, points, closed, stroke.dash, viewportScale);
-    }
-    else {
+    const appendedDash = stroke.dash?.length
+        ? appendDashedPath(graphics, points, closed, stroke.dash, viewportScale)
+        : false;
+    if (!appendedDash) {
         graphics.moveTo(points[0].x, points[0].y);
         for (let index = 1; index < points.length; index += 1) {
             graphics.lineTo(points[index].x, points[index].y);
@@ -2809,16 +3255,21 @@ function drawPixiPath(graphics, points, closed, stroke, viewportScale) {
 function resolvePixiStroke(stroke, viewportScale) {
     const pixiStroke = {
         alpha: stroke.alpha,
+        ...(stroke.cap === undefined ? {} : { cap: stroke.cap }),
         color: stroke.color,
+        ...(stroke.join === undefined ? {} : { join: stroke.join }),
+        ...(stroke.miterLimit === undefined
+            ? {}
+            : { miterLimit: stroke.miterLimit }),
         width: resolveScreenLength(stroke.width, viewportScale),
     };
     if (stroke.alignment === undefined)
         return pixiStroke;
     return {
         ...pixiStroke,
-        alignment: stroke.alignment === BoxStrokeAlignment.Inside
+        alignment: stroke.alignment === StrokeAlignment.Inside
             ? 1
-            : stroke.alignment === BoxStrokeAlignment.Outside
+            : stroke.alignment === StrokeAlignment.Outside
                 ? 0
                 : 0.5,
     };
@@ -2828,7 +3279,7 @@ function appendDashedPath(graphics, points, closed, dashPattern, viewportScale)
         .filter((value) => Number.isFinite(value) && value > 0)
         .map((value) => resolveScreenLength(value, viewportScale));
     if (pattern.length === 0) {
-        return;
+        return false;
     }
     if (pattern.length % 2 === 1) {
         pattern.push(...pattern);
@@ -2836,6 +3287,7 @@ function appendDashedPath(graphics, points, closed, dashPattern, viewportScale)
     let patternIndex = 0;
     let patternRemaining = pattern[0];
     let drawing = true;
+    let penDown = false;
     const segmentCount = closed ? points.length : points.length - 1;
     for (let segmentIndex = 0; segmentIndex < segmentCount; segmentIndex += 1) {
         const start = points[segmentIndex];
@@ -2856,8 +3308,14 @@ function appendDashedPath(graphics, points, closed, dashPattern, viewportScale)
             const x2 = start.x + dx * endRatio;
             const y2 = start.y + dy * endRatio;
             if (drawing) {
-                graphics.moveTo(x1, y1);
+                if (!penDown) {
+                    graphics.moveTo(x1, y1);
+                }
                 graphics.lineTo(x2, y2);
+                penDown = true;
+            }
+            else {
+                penDown = false;
             }
             offset += step;
             patternRemaining -= step;
@@ -2865,9 +3323,13 @@ function appendDashedPath(graphics, points, closed, dashPattern, viewportScale)
                 patternIndex = (patternIndex + 1) % pattern.length;
                 patternRemaining = pattern[patternIndex];
                 drawing = !drawing;
+                if (!drawing) {
+                    penDown = false;
+                }
             }
         }
     }
+    return true;
 }
 
 function createPixiBoxLayer(options) {
@@ -3104,13 +3566,19 @@ function createPixiFocusLayer(options) {
                 hide();
                 return;
             }
-            const instruction = focusStyle.resolve({
+            const resolvedInstruction = focusStyle.resolve({
                 frame: context.frame,
                 hoveredPick: context.hoveredPick,
                 mediaTime: context.mediaTime,
                 selectedPick: context.selectedPick,
                 viewportScale: context.viewportScale,
             });
+            const instruction = resolvedInstruction
+                ? {
+                    ...resolvedInstruction,
+                    targets: resolvedInstruction.targets.filter(({ detection }) => options.isDetectionVisible?.(detection) ?? true),
+                }
+                : undefined;
             if (!instruction || instruction.targets.length === 0) {
                 transitionToHidden();
                 return;
@@ -3322,7 +3790,7 @@ function createFocusIdMaskRenderer(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas$2(),
+        resource: createPlaceholderCanvas$3(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -3414,7 +3882,7 @@ function createPremultipliedColor(fill) {
         alpha,
     ]);
 }
-function createPlaceholderCanvas$2() {
+function createPlaceholderCanvas$3() {
     const canvas = document.createElement("canvas");
     canvas.height = 1;
     canvas.width = 1;
@@ -3536,15 +4004,21 @@ function createPixiInteractionLayer(options) {
         drawFrame(mediaTime) {
             currentMediaTime = mediaTime;
             activeFrame = options.detectionTimeline.selectFrame(mediaTime);
-            if (!canHandleInteraction()) {
-                pointerPoint = null;
-                marqueeRect = null;
-                setHoveredPick(null);
-                setSelectedPick(null);
-            }
-            else {
+            if (canHandleInteraction()) {
                 clearStalePicks(activeFrame);
+                return;
+            }
+            pointerPoint = null;
+            marqueeRect = null;
+            setHoveredPick(null);
+            if (isDestroyed || mode === MediaInteractionMode.Disabled) {
+                setSelectedPick(null);
+                return;
             }
+            // Paused-only interaction gates new picks during playback, but an
+            // existing selection keeps following its detection so selection-driven
+            // presentation such as focus survives frame advances.
+            followSelectedPicks(activeFrame);
         },
         setSelectedDetection(selection) {
             if (selection === null) {
@@ -3563,14 +4037,15 @@ function createPixiInteractionLayer(options) {
             return createState();
         },
         cycleSelection(direction = 1) {
-            if (!activeFrame?.detections.length)
+            const visibleDetections = activeFrame?.detections.flatMap((detection, detectionIndex) => canPickDetection(detection) ? [{ detection, detectionIndex }] : []);
+            if (!activeFrame || !visibleDetections?.length)
                 return null;
-            const currentIndex = selectedPick?.detectionIndex ?? (direction > 0 ? -1 : 0);
-            const nextIndex = (currentIndex + direction + activeFrame.detections.length) %
-                activeFrame.detections.length;
-            const detection = activeFrame.detections[nextIndex];
+            const currentVisibleIndex = visibleDetections.findIndex(({ detectionIndex }) => detectionIndex === selectedPick?.detectionIndex);
+            const nextVisibleIndex = (currentVisibleIndex + direction + visibleDetections.length) %
+                visibleDetections.length;
+            const { detection, detectionIndex } = visibleDetections[nextVisibleIndex];
             const next = createPickFromSelection({
-                detectionIndex: nextIndex,
+                detectionIndex,
                 point: getDetectionCenter(detection),
             });
             setSelectedPick(next);
@@ -3699,6 +4174,8 @@ function createPixiInteractionLayer(options) {
             return;
         if (didDragMarquee && marqueeRect && activeFrame) {
             selectedPicks = activeFrame.detections.flatMap((detection, detectionIndex) => {
+                if (!canPickDetection(detection))
+                    return [];
                 const rect = getDetectionRect(detection);
                 if (!rect || !intersects(rect, marqueeRect))
                     return [];
@@ -3735,10 +4212,13 @@ function createPixiInteractionLayer(options) {
         const pickPoint = { x: point.x, y: point.y };
         const labelPick = options.pickLabelDetectionAtPoint?.(pickPoint, currentMediaTime);
         const activeLabelPick = rebaseDetectionPickToFrame(labelPick ?? null, activeFrame);
-        if (activeLabelPick)
+        if (activeLabelPick && canPickDetection(activeLabelPick.detection)) {
             return activeLabelPick;
+        }
         const geometryPick = pickDetectionAtPoint(activeFrame, pickPoint, {
             ...options.interaction,
+            filter: (detection, detectionIndex) => canPickDetection(detection) &&
+                (options.interaction.filter?.(detection, detectionIndex) ?? true),
             includeMasks: options.pickMaskDetectionAtPoint === undefined,
             maskMediaDimensions: options.getMediaDimensions?.(),
             padding: pickPadding,
@@ -3748,7 +4228,9 @@ function createPixiInteractionLayer(options) {
         }
         const maskPick = options.pickMaskDetectionAtPoint?.(pickPoint, currentMediaTime);
         const activeMaskPick = rebaseDetectionPickToFrame(maskPick ?? null, activeFrame);
-        return activeMaskPick ?? geometryPick;
+        return activeMaskPick && canPickDetection(activeMaskPick.detection)
+            ? activeMaskPick
+            : geometryPick;
     }
     function createPickFromSelection(selection) {
         const frame = selection.mediaTime === undefined
@@ -3760,7 +4242,10 @@ function createPixiInteractionLayer(options) {
         const detection = detectionIndex === undefined || detectionIndex < 0
             ? undefined
             : frame?.detections[detectionIndex];
-        if (!frame || detectionIndex === undefined || !detection) {
+        if (!frame ||
+            detectionIndex === undefined ||
+            !detection ||
+            !canPickDetection(detection)) {
             return null;
         }
         return {
@@ -3774,19 +4259,44 @@ function createPixiInteractionLayer(options) {
         };
     }
     function clearStalePicks(frame) {
-        const nextHoveredPick = rebaseDetectionPickToFrame(hoveredPick, frame);
-        const nextSelectedPick = rebaseDetectionPickToFrame(selectedPick, frame);
+        // Hover stays bound to the pointer, so it keeps a per-frame lifetime.
+        const nextHoveredPick = filterPick(rebaseDetectionPickToFrame(hoveredPick, frame));
         if (hoveredPick && !nextHoveredPick) {
             setHoveredPick(null);
         }
         else if (nextHoveredPick && nextHoveredPick !== hoveredPick) {
-            setHoveredPick(nextHoveredPick);
+            // Hover remains pointer-owned. Refresh its frame snapshot without
+            // emitting a second event-driven redraw from the normal frame path.
+            hoveredPick = nextHoveredPick;
+            hoveredPickKey = createDetectionPickKey(nextHoveredPick);
         }
-        if (selectedPick && !nextSelectedPick) {
-            setSelectedPick(null);
+        followSelectedPicks(frame);
+    }
+    function followSelectedPicks(frame) {
+        if (selectedPicks.length === 0) {
+            return;
+        }
+        const nextSelectedPicks = selectedPicks.flatMap((pick) => {
+            const nextPick = filterPick(followDetectionPickAcrossFrames(pick, frame));
+            return nextPick ? [nextPick] : [];
+        });
+        const currentKeys = selectedPicks.map(createDetectionPickKey).join("|");
+        const nextKeys = nextSelectedPicks.map(createDetectionPickKey).join("|");
+        const identityChanged = !haveSameDetectionPickIdentities(selectedPicks, nextSelectedPicks);
+        selectedPicks = nextSelectedPicks;
+        selectedPick = nextSelectedPicks.at(-1) ?? null;
+        if (nextKeys === currentKeys) {
+            return;
         }
-        else if (nextSelectedPick && nextSelectedPick !== selectedPick) {
-            setSelectedPick(nextSelectedPick);
+        selectedPickKey = createDetectionPickKey(selectedPick);
+        // A followed pick re-bases onto every new frame, so its full pick key
+        // changes at playback rate. The scene's normal frame path consumes this
+        // refreshed state immediately; emitting onStateChange here would redraw
+        // focus and interaction a second time. Public callbacks only report
+        // identity or membership changes.
+        if (identityChanged) {
+            options.interaction.onSelect?.(selectedPick);
+            options.interaction.onSelectionChange?.(selectedPicks);
         }
     }
     function setHoveredPick(nextPick) {
@@ -3895,6 +4405,12 @@ function createPixiInteractionLayer(options) {
         }
         return options.canInteract();
     }
+    function canPickDetection(detection) {
+        return options.canPickDetection?.(detection) ?? true;
+    }
+    function filterPick(pick) {
+        return pick && canPickDetection(pick.detection) ? pick : null;
+    }
 }
 function getDetectionCenter(detection) {
     const rect = getDetectionRect(detection);
@@ -3940,8 +4456,11 @@ function compositeMaskFrame(instructions) {
     }
     return { data, height, width };
 }
+function createMaskIdFrame(instructions) {
+    return createIdMaskFrame(materializeMaskInstructions(instructions));
+}
 async function createPngIdMaskFrame(instructions) {
-    const frame = createIdMaskFrame(materializeMaskInstructions(instructions));
+    const frame = createMaskIdFrame(instructions);
     if (!frame) {
         return undefined;
     }
@@ -4480,6 +4999,9 @@ function createPixiVectorLayer(options) {
     let keypointStyle = options.keypointStyle === undefined
         ? new BaseKeypointStyle()
         : options.keypointStyle;
+    // Shape decorations are opt-in; no default style exists so configuring
+    // nothing keeps the semantic-geometry skip untouched.
+    let shapeStyle = options.shapeStyle ?? null;
     let styleVersion = 0;
     let drawnStyleVersion = -1;
     // A versioned source can replace a frame without changing its timeline key.
@@ -4516,7 +5038,8 @@ function createPixiVectorLayer(options) {
             const resolvedDetections = frame.detections.flatMap((detection, detectionIndex) => {
                 if (!detection.polygon &&
                     !detection.polyline &&
-                    !detection.keypoints) {
+                    !detection.keypoints &&
+                    !shapeStyle) {
                     return [];
                 }
                 const resolved = resolveDetection(detection, detectionIndex, frame, mediaTime, viewportScale);
@@ -4551,6 +5074,8 @@ function createPixiVectorLayer(options) {
                 polylineStyle = styles.polylineStyle;
             if (styles.keypointStyle !== undefined)
                 keypointStyle = styles.keypointStyle;
+            if (styles.shapeStyle !== undefined)
+                shapeStyle = styles.shapeStyle;
             styleVersion += 1;
         },
         destroy() {
@@ -4595,13 +5120,16 @@ function createPixiVectorLayer(options) {
         const polygon = polygonStyle?.resolve(detection, context);
         const polyline = polylineStyle?.resolve(detection, context);
         const keypoints = keypointStyle?.resolve(detection, context);
-        if (!polygon && !polyline && !keypoints)
+        const shapes = shapeStyle?.resolve(detection, context);
+        if (!polygon && !polyline && !keypoints && !shapes?.length) {
             return undefined;
+        }
         return {
             key: detectionKey(detection, detectionIndex),
             keypoints,
             polygon,
             polyline,
+            shapes,
             zIndex: detection.zIndex ?? detectionIndex,
         };
     }
@@ -4610,7 +5138,10 @@ function createPixiVectorLayer(options) {
         if (!entry.cleared)
             graphics.clear();
         entry.cleared = false;
-        const { keypoints, polygon, polyline } = detection;
+        const { keypoints, polygon, polyline, shapes } = detection;
+        for (const shape of shapes ?? []) {
+            drawShapeInstruction(graphics, shape, viewportScale);
+        }
         if (polygon) {
             graphics.poly(polygon.points.flatMap(({ x, y }) => [x, y]), true);
             if (polygon.fill)
@@ -4628,31 +5159,102 @@ function createPixiVectorLayer(options) {
             drawPixiPath(graphics, [edge.from, edge.to], false, edge.stroke, viewportScale);
         }
         for (const marker of keypoints.markers) {
-            const radius = resolveScreenLength(marker.radius, viewportScale);
             if (marker.shape === KeypointMarkerShape.Cross) {
-                drawPixiPath(graphics, [
-                    { x: marker.point.x - radius, y: marker.point.y - radius },
-                    { x: marker.point.x + radius, y: marker.point.y + radius },
-                ], false, marker.stroke ?? { alpha: 1, color: 0xffffff, width: 2 }, viewportScale);
-                drawPixiPath(graphics, [
-                    { x: marker.point.x + radius, y: marker.point.y - radius },
-                    { x: marker.point.x - radius, y: marker.point.y + radius },
-                ], false, marker.stroke ?? { alpha: 1, color: 0xffffff, width: 2 }, viewportScale);
+                drawMarkerInstruction(graphics, {
+                    center: marker.point,
+                    kind: ShapeInstructionKind.Marker,
+                    shape: MarkerShape.Cross,
+                    size: marker.radius * 2,
+                    sizeSpace: MarkerSizeSpace.Screen,
+                    stroke: asOpenStroke(marker.stroke ?? { alpha: 1, color: 0xffffff, width: 2 }),
+                }, viewportScale);
             }
             else {
-                graphics.circle(marker.point.x, marker.point.y, radius);
-                if (marker.fill)
-                    graphics.fill(marker.fill);
-                if (marker.stroke)
-                    graphics.stroke({
-                        alpha: marker.stroke.alpha,
-                        color: marker.stroke.color,
-                        width: resolveScreenLength(marker.stroke.width, viewportScale),
-                    });
+                drawMarkerInstruction(graphics, {
+                    center: marker.point,
+                    fill: marker.fill,
+                    kind: ShapeInstructionKind.Marker,
+                    shape: MarkerShape.Circle,
+                    size: marker.radius * 2,
+                    sizeSpace: MarkerSizeSpace.Screen,
+                    stroke: marker.stroke,
+                }, viewportScale);
+            }
+        }
+    }
+}
+function drawShapeInstruction(graphics, instruction, viewportScale) {
+    if (instruction.kind === ShapeInstructionKind.Ellipse) {
+        const { closed, points } = sampleEllipseArc(instruction, resolveEllipseSegmentCount(instruction, viewportScale));
+        if (closed && instruction.fill) {
+            graphics.poly(points.flatMap(({ x, y }) => [x, y]), true);
+            graphics.fill(instruction.fill);
+        }
+        if (instruction.stroke) {
+            drawPixiPath(graphics, points, closed, instruction.stroke, viewportScale);
+        }
+        return;
+    }
+    if (instruction.kind === ShapeInstructionKind.Marker) {
+        drawMarkerInstruction(graphics, instruction, viewportScale);
+        return;
+    }
+    for (const segment of instruction.segments) {
+        if (instruction.closed && instruction.fill) {
+            graphics.poly(segment.flatMap(({ x, y }) => [x, y]), true);
+            graphics.fill(instruction.fill);
+        }
+        drawPixiPath(graphics, segment, instruction.closed, instruction.stroke, viewportScale);
+    }
+}
+function drawMarkerInstruction(graphics, instruction, viewportScale) {
+    const geometry = resolveMarkerGeometry(instruction, viewportScale);
+    if (geometry.kind === "circle") {
+        const dashed = Boolean(instruction.stroke?.dash?.length);
+        if (instruction.fill || !dashed) {
+            graphics.circle(geometry.center.x, geometry.center.y, geometry.radius);
+            if (instruction.fill)
+                graphics.fill(instruction.fill);
+        }
+        if (instruction.stroke) {
+            if (dashed) {
+                const ellipse = {
+                    center: geometry.center,
+                    radiusX: geometry.radius,
+                    radiusY: geometry.radius,
+                };
+                const { points } = sampleEllipseArc(ellipse, resolveEllipseSegmentCount(ellipse, viewportScale));
+                drawPixiPath(graphics, points, true, instruction.stroke, viewportScale);
+            }
+            else {
+                graphics.stroke(resolvePixiStroke(instruction.stroke, viewportScale));
             }
         }
+        return;
+    }
+    for (const subpath of geometry.subpaths) {
+        if (geometry.closed && instruction.fill) {
+            graphics.poly(subpath.flatMap(({ x, y }) => [x, y]), true);
+            graphics.fill(instruction.fill);
+        }
+        if (instruction.stroke) {
+            drawPixiPath(graphics, subpath, geometry.closed, instruction.stroke, viewportScale);
+        }
     }
 }
+function asOpenStroke(stroke) {
+    if (!stroke)
+        return undefined;
+    return {
+        alpha: stroke.alpha,
+        cap: stroke.cap,
+        color: stroke.color,
+        dash: stroke.dash,
+        join: stroke.join,
+        miterLimit: stroke.miterLimit,
+        width: stroke.width,
+    };
+}
 function detectionKey(detection, detectionIndex) {
     return detection.id === undefined
         ? `index:${detectionIndex}`
@@ -4782,7 +5384,8 @@ function createPixiInteractionPresentationLayer(options) {
     }
     function createActivePick(pick, frame, mediaTime, state) {
         const activePick = rebaseDetectionPickToFrame(pick, frame);
-        if (!activePick) {
+        if (!activePick ||
+            options.isDetectionVisible?.(activePick.detection) === false) {
             return null;
         }
         const context = {
@@ -5039,7 +5642,7 @@ function createInteractionMaskRenderer(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas$1(),
+        resource: createPlaceholderCanvas$2(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -5150,7 +5753,7 @@ function writePaletteEntry(palette, maskId, color, alpha) {
     palette[offset + 2] = (color & 0xff) / 255;
     palette[offset + 3] = clampedAlpha;
 }
-function createPlaceholderCanvas$1() {
+function createPlaceholderCanvas$2() {
     const canvas = document.createElement("canvas");
     canvas.height = 1;
     canvas.width = 1;
@@ -5298,7 +5901,7 @@ void main(void) {
 }
 `;
 
-const EMBEDDED_MASK_PREPARATION_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex`, `frameRate`,\n         * and optional `frameIndexOriginTime`. This is useful when inference was run\n         * on normalized frames and playback should snap detections to that grid.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n    function decodeCompressedRleMask(mask) {\n        if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {\n            throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);\n        }\n        const data = new Uint8Array(mask.width * mask.height);\n        const counts = decodeCompressedRleCounts(mask.counts);\n        let offset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            const isForeground = index % 2 === 1;\n            if (isForeground) {\n                for (let runOffset = 0; runOffset < runLength; runOffset += 1) {\n                    const maskOffset = offset + runOffset;\n                    const x = Math.floor(maskOffset / mask.height);\n                    const y = maskOffset % mask.height;\n                    const rowMajorOffset = y * mask.width + x;\n                    if (rowMajorOffset < data.length) {\n                        data[rowMajorOffset] = 1;\n                    }\n                }\n            }\n            offset += runLength;\n        }\n        return {\n            data,\n            height: mask.height,\n            width: mask.width,\n        };\n    }\n    function decodeCompressedRleCounts(counts) {\n        const decoded = [];\n        let index = 0;\n        while (index < counts.length) {\n            let value = 0;\n            let shift = 0;\n            let charCode;\n            do {\n                charCode = counts.charCodeAt(index) - 48;\n                index += 1;\n                value |= (charCode & 0x1f) << shift;\n                shift += 5;\n            } while (charCode & 0x20);\n            if (charCode & 0x10) {\n                value |= -1 << shift;\n            }\n            if (decoded.length > 2) {\n                value += decoded[decoded.length - 2] ?? 0;\n            }\n            decoded.push(value);\n        }\n        return decoded;\n    }\n    function encodeCompressedRleCounts(counts) {\n        return counts\n            .map((count, index) => {\n            let value = index > 2 ? count - counts[index - 2] : count;\n            let encoded = \"\";\n            let more = true;\n            while (more) {\n                let charCode = value & 0x1f;\n                value >>= 5;\n                more = !((value === 0 && (charCode & 0x10) === 0) ||\n                    (value === -1 && (charCode & 0x10) !== 0));\n                if (more) {\n                    charCode |= 0x20;\n                }\n                encoded += String.fromCharCode(charCode + 48);\n            }\n            return encoded;\n        })\n            .join(\"\");\n    }\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    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    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 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    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n    var BoxStrokeAlignment;\n    (function (BoxStrokeAlignment) {\n        BoxStrokeAlignment[\"Inside\"] = \"inside\";\n        BoxStrokeAlignment[\"Center\"] = \"center\";\n        BoxStrokeAlignment[\"Outside\"] = \"outside\";\n    })(BoxStrokeAlignment || (BoxStrokeAlignment = {}));\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    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n    function encodeBinaryMask(data, width, height) {\n        assertMaskDimensions(data, width, height);\n        const runs = [];\n        let currentValue = 0;\n        let runLength = 0;\n        for (let x = 0; x < width; x += 1) {\n            for (let y = 0; y < height; y += 1) {\n                const value = data[y * width + x] ? 1 : 0;\n                if (value === currentValue) {\n                    runLength += 1;\n                }\n                else {\n                    runs.push(runLength);\n                    currentValue = value;\n                    runLength = 1;\n                }\n            }\n        }\n        runs.push(runLength);\n        return {\n            counts: encodeCompressedRleCounts(runs),\n            encoding: DetectionMaskEncoding.CompressedRle,\n            height,\n            width,\n        };\n    }\n    function assertMaskDimensions(data, width, height) {\n        if (!Number.isInteger(width) || width <= 0) {\n            throw new Error(\"Mask width must be a positive integer.\");\n        }\n        if (!Number.isInteger(height) || height <= 0) {\n            throw new Error(\"Mask height must be a positive integer.\");\n        }\n        if (data.length !== width * height) {\n            throw new Error(\"Mask data length must equal width * height.\");\n        }\n    }\n    function rasterizePolygonToMask(points, dimensions) {\n        const data = createEmptyMask(dimensions);\n        if (points.length < 3) {\n            return data;\n        }\n        const bounds = centerRectToTopLeftRect(getPointsRect(points));\n        const startY = Math.max(0, Math.floor(bounds.y));\n        const endY = Math.min(dimensions.height - 1, Math.ceil(bounds.y + bounds.height));\n        for (let y = startY; y <= endY; y += 1) {\n            const scanY = y + 0.5;\n            const intersections = [];\n            for (let index = 0; index < points.length; index += 1) {\n                const current = points[index];\n                const next = points[(index + 1) % points.length];\n                if ((current.y <= scanY && next.y > scanY) ||\n                    (next.y <= scanY && current.y > scanY)) {\n                    const ratio = (scanY - current.y) / (next.y - current.y);\n                    intersections.push(current.x + ratio * (next.x - current.x));\n                }\n            }\n            intersections.sort((left, right) => left - right);\n            for (let index = 0; index < intersections.length - 1; index += 2) {\n                const left = Math.max(0, Math.ceil(intersections[index]));\n                const right = Math.min(dimensions.width - 1, Math.floor(intersections[index + 1]));\n                for (let x = left; x <= right; x += 1) {\n                    data[y * dimensions.width + x] = 1;\n                }\n            }\n        }\n        return data;\n    }\n    function createEmptyMask(dimensions) {\n        if (!Number.isInteger(dimensions.width) ||\n            dimensions.width <= 0 ||\n            !Number.isInteger(dimensions.height) ||\n            dimensions.height <= 0) {\n            throw new Error(\"Media dimensions must be positive integers.\");\n        }\n        return new Uint8Array(dimensions.width * dimensions.height);\n    }\n\n    const MAX_ID_MASK_PALETTE_ENTRIES = 64;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...instructions.map(({ mask }) => mask.width));\n        const height = Math.max(...instructions.map(({ mask }) => mask.height));\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        const fillPalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokePalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokeWidths = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4));\n        let hasStroke = false;\n        let maxStrokeWidth = 0;\n        for (const instruction of instructions) {\n            const detectionMaskId = instruction.detectionIndex + 1;\n            if (detectionMaskId <= 0 ||\n                detectionMaskId >= MAX_ID_MASK_PALETTE_ENTRIES) {\n                return undefined;\n            }\n            writePaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);\n            if (instruction.stroke && instruction.stroke.width > 0) {\n                const strokeWidth = Math.min(Math.max(0, instruction.stroke.width), MAX_ID_MASK_STROKE_WIDTH);\n                hasStroke = true;\n                strokeWidths[detectionMaskId] = strokeWidth;\n                maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);\n                writePaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);\n            }\n            const decodedMask = decodeCompressedRleMask(instruction.mask);\n            for (let y = 0; y < decodedMask.height; y += 1) {\n                for (let x = 0; x < decodedMask.width; x += 1) {\n                    const maskOffset = y * decodedMask.width + x;\n                    if (decodedMask.data[maskOffset]) {\n                        data[y * width + x] = detectionMaskId;\n                    }\n                }\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\n    }\n    function writePaletteEntry(palette, id, color, alpha) {\n        const offset = id * 4;\n        palette[offset] = ((color >> 16) & 0xff) / 255;\n        palette[offset + 1] = ((color >> 8) & 0xff) / 255;\n        palette[offset + 2] = (color & 0xff) / 255;\n        palette[offset + 3] = Math.max(0, Math.min(alpha, 1));\n    }\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    const PNG_SIGNATURE = new Uint8Array([\n        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,\n    ]);\n    function compositeMaskFrame(instructions) {\n        const maskInstructions = materializeMaskInstructions(instructions);\n        if (maskInstructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...maskInstructions.map(({ mask }) => mask.width));\n        const height = Math.max(...maskInstructions.map(({ mask }) => mask.height));\n        const data = new Uint8ClampedArray(new ArrayBuffer(width * height * 4));\n        for (const instruction of maskInstructions) {\n            compositeInstruction(data, width, instruction);\n        }\n        return { data, height, width };\n    }\n    async function createPngIdMaskFrame(instructions) {\n        const frame = createIdMaskFrame(materializeMaskInstructions(instructions));\n        if (!frame) {\n            return undefined;\n        }\n        return {\n            ...frame,\n            png: await encodeGrayscalePng({\n                height: frame.height,\n                pixels: frame.data,\n                width: frame.width,\n            }),\n        };\n    }\n    function compositeInstruction(rgba, canvasWidth, instruction) {\n        const decodedMask = decodeCompressedRleMask(instruction.mask);\n        const fill = resolveRgbaColor(instruction.color, instruction.alpha);\n        compositeMaskFill(rgba, canvasWidth, decodedMask, fill);\n        if (instruction.stroke) {\n            compositeMaskStroke(rgba, canvasWidth, decodedMask, instruction.stroke);\n        }\n    }\n    function materializeMaskInstructions(instructions) {\n        return instructions.map((instruction) => {\n            if (instruction.mask) {\n                return instruction;\n            }\n            const { height, points, width } = instruction.polygon;\n            return {\n                alpha: instruction.alpha,\n                color: instruction.color,\n                detectionIndex: instruction.detectionIndex,\n                mask: encodeBinaryMask(rasterizePolygonToMask(points, { height, width }), width, height),\n                stroke: instruction.stroke,\n            };\n        });\n    }\n    function compositeMaskFill(rgba, canvasWidth, decodedMask, fill) {\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                const maskOffset = y * decodedMask.width + x;\n                if (!decodedMask.data[maskOffset]) {\n                    continue;\n                }\n                writePixel(rgba, canvasWidth, x, y, fill);\n            }\n        }\n    }\n    function compositeMaskStroke(rgba, canvasWidth, decodedMask, stroke) {\n        const width = Math.round(stroke.width);\n        if (width <= 0) {\n            return;\n        }\n        const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                if (!isMaskPixel(decodedMask, x, y) ||\n                    !isBoundaryPixel(decodedMask, x, y)) {\n                    continue;\n                }\n                for (let offsetY = -width; offsetY <= width; offsetY += 1) {\n                    for (let offsetX = -width; offsetX <= width; offsetX += 1) {\n                        const strokeX = x + offsetX;\n                        const strokeY = y + offsetY;\n                        if (isOutsideMaskBounds(decodedMask, strokeX, strokeY) ||\n                            isMaskPixel(decodedMask, strokeX, strokeY)) {\n                            continue;\n                        }\n                        writePixel(rgba, canvasWidth, strokeX, strokeY, strokeColor);\n                    }\n                }\n            }\n        }\n    }\n    function isBoundaryPixel(mask, x, y) {\n        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {\n            for (let offsetX = -1; offsetX <= 1; offsetX += 1) {\n                if (offsetX === 0 && offsetY === 0) {\n                    continue;\n                }\n                const neighborX = x + offsetX;\n                const neighborY = y + offsetY;\n                if (isOutsideMaskBounds(mask, neighborX, neighborY) ||\n                    !isMaskPixel(mask, neighborX, neighborY)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    function isMaskPixel(mask, x, y) {\n        return mask.data[y * mask.width + x] === 1;\n    }\n    function isOutsideMaskBounds(mask, x, y) {\n        return x < 0 || y < 0 || x >= mask.width || y >= mask.height;\n    }\n    function resolveRgbaColor(color, alpha) {\n        return {\n            alpha: Math.round(Math.max(0, Math.min(alpha, 1)) * 255),\n            blue: color & 0xff,\n            green: (color >> 8) & 0xff,\n            red: (color >> 16) & 0xff,\n        };\n    }\n    function writePixel(rgba, canvasWidth, x, y, color) {\n        const rgbaOffset = (y * canvasWidth + x) * 4;\n        rgba[rgbaOffset] = color.red;\n        rgba[rgbaOffset + 1] = color.green;\n        rgba[rgbaOffset + 2] = color.blue;\n        rgba[rgbaOffset + 3] = color.alpha;\n    }\n    async function encodeGrayscalePng(options) {\n        if (typeof CompressionStream === \"undefined\") {\n            throw new Error(\"CompressionStream is required to encode PNG ID masks.\");\n        }\n        const rawScanlines = createFilterlessPngScanlines(options);\n        const ihdr = new Uint8Array(13);\n        const ihdrView = new DataView(ihdr.buffer);\n        ihdrView.setUint32(0, options.width);\n        ihdrView.setUint32(4, options.height);\n        ihdr[8] = 8;\n        ihdr[9] = 0;\n        ihdr[10] = 0;\n        ihdr[11] = 0;\n        ihdr[12] = 0;\n        const compressed = new Uint8Array(await new Response(new Blob([rawScanlines])\n            .stream()\n            .pipeThrough(new CompressionStream(\"deflate\"))).arrayBuffer());\n        return concatUint8Arrays([\n            PNG_SIGNATURE,\n            createPngChunk(\"IHDR\", ihdr),\n            createPngChunk(\"IDAT\", compressed),\n            createPngChunk(\"IEND\", new Uint8Array(0)),\n        ]);\n    }\n    function createFilterlessPngScanlines(options) {\n        const rowStride = options.width + 1;\n        const scanlines = new Uint8Array(rowStride * options.height);\n        for (let y = 0; y < options.height; y += 1) {\n            const sourceOffset = y * options.width;\n            const targetOffset = y * rowStride;\n            scanlines[targetOffset] = 0;\n            scanlines.set(options.pixels.subarray(sourceOffset, sourceOffset + options.width), targetOffset + 1);\n        }\n        return scanlines;\n    }\n    function createPngChunk(type, data) {\n        const typeBytes = new TextEncoder().encode(type);\n        const chunk = new Uint8Array(12 + data.length);\n        const view = new DataView(chunk.buffer);\n        view.setUint32(0, data.length);\n        chunk.set(typeBytes, 4);\n        chunk.set(data, 8);\n        view.setUint32(8 + data.length, crc32(concatUint8Arrays([typeBytes, data])));\n        return chunk;\n    }\n    const crc32Table = createCrc32Table();\n    function createCrc32Table() {\n        const table = new Uint32Array(256);\n        for (let index = 0; index < table.length; index += 1) {\n            let value = index;\n            for (let bit = 0; bit < 8; bit += 1) {\n                value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;\n            }\n            table[index] = value >>> 0;\n        }\n        return table;\n    }\n    function crc32(bytes) {\n        let crc = 0xffffffff;\n        for (const byte of bytes) {\n            crc = crc32Table[(crc ^ byte) & 0xff] ^ (crc >>> 8);\n        }\n        return (crc ^ 0xffffffff) >>> 0;\n    }\n    function concatUint8Arrays(chunks) {\n        const totalLength = chunks.reduce((total, chunk) => total + chunk.length, 0);\n        const result = new Uint8Array(totalLength);\n        let offset = 0;\n        for (const chunk of chunks) {\n            result.set(chunk, offset);\n            offset += chunk.length;\n        }\n        return result;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"PngIdMask\"] = \"pngIdMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\n\n    var MaskPreparationWorkerMessageType;\n    (function (MaskPreparationWorkerMessageType) {\n        MaskPreparationWorkerMessageType[\"Complete\"] = \"complete\";\n        MaskPreparationWorkerMessageType[\"Empty\"] = \"empty\";\n        MaskPreparationWorkerMessageType[\"Error\"] = \"error\";\n        MaskPreparationWorkerMessageType[\"Prepare\"] = \"prepare\";\n    })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));\n\n    const workerScope = globalThis;\n    workerScope.addEventListener(\"message\", (event) => {\n        const message = event.data;\n        if (message.type !== MaskPreparationWorkerMessageType.Prepare) {\n            return;\n        }\n        void prepareMaskFrame(message);\n    });\n    async function prepareMaskFrame(message) {\n        try {\n            const pngIdMaskFrame = await createPngIdMaskWorkerResponse(message);\n            if (pngIdMaskFrame) {\n                workerScope.postMessage(pngIdMaskFrame, [\n                    pngIdMaskFrame.imageBitmap,\n                    pngIdMaskFrame.png.buffer,\n                    pngIdMaskFrame.fillPalette.buffer,\n                    pngIdMaskFrame.strokePalette.buffer,\n                    pngIdMaskFrame.strokeWidths.buffer,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const imageData = new ImageData(compositedFrame.data, compositedFrame.width, compositedFrame.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    imageBitmap,\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [imageBitmap]);\n                return;\n            }\n            workerScope.postMessage({\n                imageData,\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [imageData.data.buffer]);\n        }\n        catch (error) {\n            workerScope.postMessage({\n                error: error instanceof Error\n                    ? error.message\n                    : \"Unable to prepare mask frame.\",\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Error,\n            });\n        }\n    }\n    async function createPngIdMaskWorkerResponse(message) {\n        if (typeof Blob === \"undefined\" ||\n            typeof createImageBitmap === \"undefined\" ||\n            typeof CompressionStream === \"undefined\") {\n            return undefined;\n        }\n        let frame;\n        try {\n            frame = await createPngIdMaskFrame(message.job.instructions);\n        }\n        catch {\n            return undefined;\n        }\n        if (!frame) {\n            return undefined;\n        }\n        let imageBitmap;\n        try {\n            imageBitmap = await createImageBitmap(new Blob([frame.png], { type: \"image/png\" }));\n        }\n        catch {\n            return undefined;\n        }\n        return {\n            artifactKind: PreparedMaskFrameKind.PngIdMask,\n            fillPalette: frame.fillPalette,\n            hasStroke: frame.hasStroke,\n            imageBitmap,\n            key: message.job.key,\n            maxStrokeWidth: frame.maxStrokeWidth,\n            png: frame.png,\n            requestId: message.requestId,\n            strokePalette: frame.strokePalette,\n            strokeWidths: frame.strokeWidths,\n            type: MaskPreparationWorkerMessageType.Complete,\n        };\n    }\n    function createImageBitmapFromImageData(imageData) {\n        if (typeof OffscreenCanvas === \"undefined\") {\n            return null;\n        }\n        const canvas = new OffscreenCanvas(imageData.width, imageData.height);\n        const context = canvas.getContext(\"2d\");\n        if (!context) {\n            return null;\n        }\n        context.putImageData(imageData, 0, 0);\n        return canvas.transferToImageBitmap();\n    }\n\n})();";
+const EMBEDDED_MASK_PREPARATION_WORKER_SOURCE = "(function () {\n    'use strict';\n\n    /** COCO-compatible keypoint visibility values. */\n    var KeypointVisibility;\n    (function (KeypointVisibility) {\n        KeypointVisibility[KeypointVisibility[\"NotLabeled\"] = 0] = \"NotLabeled\";\n        KeypointVisibility[KeypointVisibility[\"Occluded\"] = 1] = \"Occluded\";\n        KeypointVisibility[KeypointVisibility[\"Visible\"] = 2] = \"Visible\";\n    })(KeypointVisibility || (KeypointVisibility = {}));\n    var DetectionMaskEncoding;\n    (function (DetectionMaskEncoding) {\n        DetectionMaskEncoding[\"CompressedRle\"] = \"compressedRle\";\n    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));\n\n    var DetectionBufferStatus;\n    (function (DetectionBufferStatus) {\n        DetectionBufferStatus[\"Idle\"] = \"idle\";\n        DetectionBufferStatus[\"Loading\"] = \"loading\";\n        DetectionBufferStatus[\"Ready\"] = \"ready\";\n        DetectionBufferStatus[\"Error\"] = \"error\";\n        DetectionBufferStatus[\"Destroyed\"] = \"destroyed\";\n    })(DetectionBufferStatus || (DetectionBufferStatus = {}));\n    /**\n     * How the renderer selects the active detection frame for a media timestamp.\n     */\n    var DetectionFrameSelectionMode;\n    (function (DetectionFrameSelectionMode) {\n        /**\n         * Select the frame whose `[mediaTime, endTime)` interval contains the media\n         * time. This is the default for interval annotations and timestamped sources.\n         */\n        DetectionFrameSelectionMode[\"Interval\"] = \"interval\";\n        /**\n         * Select from a known inference frame grid using `frameIndex`, `frameRate`,\n         * and optional `frameIndexOriginTime`. This is useful when inference was run\n         * on normalized frames and playback should snap detections to that grid.\n         */\n        DetectionFrameSelectionMode[\"NearestFrameIndex\"] = \"nearestFrameIndex\";\n    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));\n    var DetectionFrameRetentionMode;\n    (function (DetectionFrameRetentionMode) {\n        /**\n         * Keep writable detections only in an in-memory store. Useful for ephemeral\n         * live streams where old predictions should disappear when evicted.\n         */\n        DetectionFrameRetentionMode[\"MemoryOnly\"] = \"memoryOnly\";\n        /**\n         * Persist every written detection frame. Useful for finite media where seek\n         * and replay should not require recomputing detections.\n         */\n        DetectionFrameRetentionMode[\"PersistAll\"] = \"persistAll\";\n        /**\n         * Persist only the most recent retention window. Useful for long-running\n         * streams where replay is bounded to a recent time horizon.\n         */\n        DetectionFrameRetentionMode[\"PersistWindow\"] = \"persistWindow\";\n    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));\n    function decodeCompressedRleMask(mask) {\n        if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {\n            throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);\n        }\n        const data = new Uint8Array(mask.width * mask.height);\n        const counts = decodeCompressedRleCounts(mask.counts);\n        let offset = 0;\n        for (let index = 0; index < counts.length; index += 1) {\n            const runLength = counts[index] ?? 0;\n            const isForeground = index % 2 === 1;\n            if (isForeground) {\n                for (let runOffset = 0; runOffset < runLength; runOffset += 1) {\n                    const maskOffset = offset + runOffset;\n                    const x = Math.floor(maskOffset / mask.height);\n                    const y = maskOffset % mask.height;\n                    const rowMajorOffset = y * mask.width + x;\n                    if (rowMajorOffset < data.length) {\n                        data[rowMajorOffset] = 1;\n                    }\n                }\n            }\n            offset += runLength;\n        }\n        return {\n            data,\n            height: mask.height,\n            width: mask.width,\n        };\n    }\n    function decodeCompressedRleCounts(counts) {\n        const decoded = [];\n        let index = 0;\n        while (index < counts.length) {\n            let value = 0;\n            let shift = 0;\n            let charCode;\n            do {\n                charCode = counts.charCodeAt(index) - 48;\n                index += 1;\n                value |= (charCode & 0x1f) << shift;\n                shift += 5;\n            } while (charCode & 0x20);\n            if (charCode & 0x10) {\n                value |= -1 << shift;\n            }\n            if (decoded.length > 2) {\n                value += decoded[decoded.length - 2] ?? 0;\n            }\n            decoded.push(value);\n        }\n        return decoded;\n    }\n    function encodeCompressedRleCounts(counts) {\n        return counts\n            .map((count, index) => {\n            let value = index > 2 ? count - counts[index - 2] : count;\n            let encoded = \"\";\n            let more = true;\n            while (more) {\n                let charCode = value & 0x1f;\n                value >>= 5;\n                more = !((value === 0 && (charCode & 0x10) === 0) ||\n                    (value === -1 && (charCode & 0x10) !== 0));\n                if (more) {\n                    charCode |= 0x20;\n                }\n                encoded += String.fromCharCode(charCode + 48);\n            }\n            return encoded;\n        })\n            .join(\"\");\n    }\n\n    var AnnotationFrameMutationKind;\n    (function (AnnotationFrameMutationKind) {\n        AnnotationFrameMutationKind[\"Add\"] = \"add\";\n        AnnotationFrameMutationKind[\"Remove\"] = \"remove\";\n        AnnotationFrameMutationKind[\"Replace\"] = \"replace\";\n        AnnotationFrameMutationKind[\"Transact\"] = \"transact\";\n        AnnotationFrameMutationKind[\"Update\"] = \"update\";\n    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));\n\n    /** Geometry projected into a tracker. The original detection payload is retained. */\n    var TrackingGeometry;\n    (function (TrackingGeometry) {\n        TrackingGeometry[\"Box\"] = \"box\";\n        TrackingGeometry[\"Mask\"] = \"mask\";\n        TrackingGeometry[\"Keypoints\"] = \"keypoints\";\n    })(TrackingGeometry || (TrackingGeometry = {}));\n\n    var DetectionMaskPayloadFormat;\n    (function (DetectionMaskPayloadFormat) {\n        DetectionMaskPayloadFormat[\"RawCocoRle\"] = \"rawCocoRle\";\n        DetectionMaskPayloadFormat[\"DeflatedBase64\"] = \"deflatedBase64\";\n    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));\n    function encodeBinaryMask(data, width, height) {\n        assertMaskDimensions(data, width, height);\n        const runs = [];\n        let currentValue = 0;\n        let runLength = 0;\n        for (let x = 0; x < width; x += 1) {\n            for (let y = 0; y < height; y += 1) {\n                const value = data[y * width + x] ? 1 : 0;\n                if (value === currentValue) {\n                    runLength += 1;\n                }\n                else {\n                    runs.push(runLength);\n                    currentValue = value;\n                    runLength = 1;\n                }\n            }\n        }\n        runs.push(runLength);\n        return {\n            counts: encodeCompressedRleCounts(runs),\n            encoding: DetectionMaskEncoding.CompressedRle,\n            height,\n            width,\n        };\n    }\n    function assertMaskDimensions(data, width, height) {\n        if (!Number.isInteger(width) || width <= 0) {\n            throw new Error(\"Mask width must be a positive integer.\");\n        }\n        if (!Number.isInteger(height) || height <= 0) {\n            throw new Error(\"Mask height must be a positive integer.\");\n        }\n        if (data.length !== width * height) {\n            throw new Error(\"Mask data length must equal width * height.\");\n        }\n    }\n\n    function centerRectToTopLeftRect(rect) {\n        return {\n            height: rect.height,\n            width: rect.width,\n            x: rect.x - rect.width / 2,\n            y: rect.y - rect.height / 2,\n        };\n    }\n    function getPointsRect(points) {\n        if (points.length === 0) {\n            return undefined;\n        }\n        let minX = Number.POSITIVE_INFINITY;\n        let minY = Number.POSITIVE_INFINITY;\n        let maxX = Number.NEGATIVE_INFINITY;\n        let maxY = Number.NEGATIVE_INFINITY;\n        for (const point of points) {\n            minX = Math.min(minX, point.x);\n            minY = Math.min(minY, point.y);\n            maxX = Math.max(maxX, point.x);\n            maxY = Math.max(maxY, point.y);\n        }\n        return {\n            height: maxY - minY,\n            width: maxX - minX,\n            x: (minX + maxX) / 2,\n            y: (minY + maxY) / 2,\n        };\n    }\n\n    var DetectionPickTarget;\n    (function (DetectionPickTarget) {\n        DetectionPickTarget[\"Box\"] = \"box\";\n        DetectionPickTarget[\"Edge\"] = \"edge\";\n        DetectionPickTarget[\"Keypoint\"] = \"keypoint\";\n        DetectionPickTarget[\"Label\"] = \"label\";\n        DetectionPickTarget[\"Mask\"] = \"mask\";\n        DetectionPickTarget[\"Polygon\"] = \"polygon\";\n        DetectionPickTarget[\"Polyline\"] = \"polyline\";\n    })(DetectionPickTarget || (DetectionPickTarget = {}));\n    var MediaInteractionMode;\n    (function (MediaInteractionMode) {\n        MediaInteractionMode[\"Always\"] = \"always\";\n        MediaInteractionMode[\"Disabled\"] = \"disabled\";\n        MediaInteractionMode[\"PausedOnly\"] = \"pausedOnly\";\n    })(MediaInteractionMode || (MediaInteractionMode = {}));\n\n    var AnnotationGeometryKind;\n    (function (AnnotationGeometryKind) {\n        AnnotationGeometryKind[\"Box\"] = \"box\";\n        AnnotationGeometryKind[\"Polygon\"] = \"polygon\";\n        AnnotationGeometryKind[\"Polyline\"] = \"polyline\";\n        AnnotationGeometryKind[\"Keypoints\"] = \"keypoints\";\n        AnnotationGeometryKind[\"Mask\"] = \"mask\";\n    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));\n    var AnnotationGestureStateKind;\n    (function (AnnotationGestureStateKind) {\n        AnnotationGestureStateKind[\"Idle\"] = \"idle\";\n        AnnotationGestureStateKind[\"Creating\"] = \"creating\";\n        AnnotationGestureStateKind[\"Moving\"] = \"moving\";\n        AnnotationGestureStateKind[\"Resizing\"] = \"resizing\";\n        AnnotationGestureStateKind[\"DragSelecting\"] = \"dragSelecting\";\n    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));\n    var AnnotationHandleKind;\n    (function (AnnotationHandleKind) {\n        AnnotationHandleKind[\"Resize\"] = \"resize\";\n        AnnotationHandleKind[\"Vertex\"] = \"vertex\";\n        AnnotationHandleKind[\"AddVertex\"] = \"addVertex\";\n        AnnotationHandleKind[\"Keypoint\"] = \"keypoint\";\n    })(AnnotationHandleKind || (AnnotationHandleKind = {}));\n\n    /** Alignment for strokes applied to closed rendered geometry. */\n    var StrokeAlignment;\n    (function (StrokeAlignment) {\n        StrokeAlignment[\"Inside\"] = \"inside\";\n        StrokeAlignment[\"Center\"] = \"center\";\n        StrokeAlignment[\"Outside\"] = \"outside\";\n    })(StrokeAlignment || (StrokeAlignment = {}));\n\n    var BoxShape;\n    (function (BoxShape) {\n        BoxShape[\"Rect\"] = \"rect\";\n        BoxShape[\"RoundedRect\"] = \"roundedRect\";\n    })(BoxShape || (BoxShape = {}));\n\n    var FocusTargetMode;\n    (function (FocusTargetMode) {\n        FocusTargetMode[\"Hovered\"] = \"hovered\";\n        FocusTargetMode[\"Selected\"] = \"selected\";\n        FocusTargetMode[\"HoveredAndSelected\"] = \"hoveredAndSelected\";\n        FocusTargetMode[\"Ambient\"] = \"ambient\";\n    })(FocusTargetMode || (FocusTargetMode = {}));\n\n    var DetectionInteractionState;\n    (function (DetectionInteractionState) {\n        DetectionInteractionState[\"Hovered\"] = \"hovered\";\n        DetectionInteractionState[\"Selected\"] = \"selected\";\n    })(DetectionInteractionState || (DetectionInteractionState = {}));\n\n    var LabelPlacement;\n    (function (LabelPlacement) {\n        LabelPlacement[\"Top\"] = \"top\";\n        LabelPlacement[\"Bottom\"] = \"bottom\";\n        LabelPlacement[\"InsideTop\"] = \"insideTop\";\n        LabelPlacement[\"InsideBottom\"] = \"insideBottom\";\n        LabelPlacement[\"Center\"] = \"center\";\n    })(LabelPlacement || (LabelPlacement = {}));\n    var LabelVisibilityMode;\n    (function (LabelVisibilityMode) {\n        LabelVisibilityMode[\"Always\"] = \"always\";\n        LabelVisibilityMode[\"HoveredOnly\"] = \"hoveredOnly\";\n    })(LabelVisibilityMode || (LabelVisibilityMode = {}));\n\n    var MaskRenderMode;\n    (function (MaskRenderMode) {\n        MaskRenderMode[\"FillAndStroke\"] = \"fillAndStroke\";\n        MaskRenderMode[\"FillOnly\"] = \"fillOnly\";\n        MaskRenderMode[\"StrokeOnly\"] = \"strokeOnly\";\n    })(MaskRenderMode || (MaskRenderMode = {}));\n\n    /**\n     * Discriminator for renderer-neutral shape draw instructions.\n     */\n    var ShapeInstructionKind;\n    (function (ShapeInstructionKind) {\n        ShapeInstructionKind[\"Ellipse\"] = \"ellipse\";\n        ShapeInstructionKind[\"Marker\"] = \"marker\";\n        ShapeInstructionKind[\"Path\"] = \"path\";\n    })(ShapeInstructionKind || (ShapeInstructionKind = {}));\n    var MarkerShape;\n    (function (MarkerShape) {\n        MarkerShape[\"Circle\"] = \"circle\";\n        MarkerShape[\"Cross\"] = \"cross\";\n        MarkerShape[\"Square\"] = \"square\";\n        MarkerShape[\"Triangle\"] = \"triangle\";\n    })(MarkerShape || (MarkerShape = {}));\n    /**\n     * Coordinate space for marker sizing. Media sizes scale with the viewport;\n     * screen sizes stay constant on screen, matching stroke-width semantics.\n     */\n    var MarkerSizeSpace;\n    (function (MarkerSizeSpace) {\n        MarkerSizeSpace[\"Media\"] = \"media\";\n        MarkerSizeSpace[\"Screen\"] = \"screen\";\n    })(MarkerSizeSpace || (MarkerSizeSpace = {}));\n\n    var KeypointMarkerShape;\n    (function (KeypointMarkerShape) {\n        KeypointMarkerShape[\"Circle\"] = \"circle\";\n        KeypointMarkerShape[\"Cross\"] = \"cross\";\n    })(KeypointMarkerShape || (KeypointMarkerShape = {}));\n    function rasterizePolygonToMask(points, dimensions) {\n        const data = createEmptyMask(dimensions);\n        if (points.length < 3) {\n            return data;\n        }\n        const bounds = centerRectToTopLeftRect(getPointsRect(points));\n        const startY = Math.max(0, Math.floor(bounds.y));\n        const endY = Math.min(dimensions.height - 1, Math.ceil(bounds.y + bounds.height));\n        for (let y = startY; y <= endY; y += 1) {\n            const scanY = y + 0.5;\n            const intersections = [];\n            for (let index = 0; index < points.length; index += 1) {\n                const current = points[index];\n                const next = points[(index + 1) % points.length];\n                if ((current.y <= scanY && next.y > scanY) ||\n                    (next.y <= scanY && current.y > scanY)) {\n                    const ratio = (scanY - current.y) / (next.y - current.y);\n                    intersections.push(current.x + ratio * (next.x - current.x));\n                }\n            }\n            intersections.sort((left, right) => left - right);\n            for (let index = 0; index < intersections.length - 1; index += 2) {\n                const left = Math.max(0, Math.ceil(intersections[index]));\n                const right = Math.min(dimensions.width - 1, Math.floor(intersections[index + 1]));\n                for (let x = left; x <= right; x += 1) {\n                    data[y * dimensions.width + x] = 1;\n                }\n            }\n        }\n        return data;\n    }\n    function createEmptyMask(dimensions) {\n        if (!Number.isInteger(dimensions.width) ||\n            dimensions.width <= 0 ||\n            !Number.isInteger(dimensions.height) ||\n            dimensions.height <= 0) {\n            throw new Error(\"Media dimensions must be positive integers.\");\n        }\n        return new Uint8Array(dimensions.width * dimensions.height);\n    }\n\n    const MAX_ID_MASK_PALETTE_ENTRIES = 64;\n    const MAX_ID_MASK_STROKE_WIDTH = 16;\n    function createIdMaskFrame(instructions) {\n        if (instructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...instructions.map(({ mask }) => mask.width));\n        const height = Math.max(...instructions.map(({ mask }) => mask.height));\n        const data = new Uint8Array(new ArrayBuffer(width * height));\n        const fillPalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokePalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));\n        const strokeWidths = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4));\n        let hasStroke = false;\n        let maxStrokeWidth = 0;\n        for (const instruction of instructions) {\n            const detectionMaskId = instruction.detectionIndex + 1;\n            if (detectionMaskId <= 0 ||\n                detectionMaskId >= MAX_ID_MASK_PALETTE_ENTRIES) {\n                return undefined;\n            }\n            writePaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);\n            if (instruction.stroke && instruction.stroke.width > 0) {\n                const strokeWidth = Math.min(Math.max(0, instruction.stroke.width), MAX_ID_MASK_STROKE_WIDTH);\n                hasStroke = true;\n                strokeWidths[detectionMaskId] = strokeWidth;\n                maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);\n                writePaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);\n            }\n            const decodedMask = decodeCompressedRleMask(instruction.mask);\n            for (let y = 0; y < decodedMask.height; y += 1) {\n                for (let x = 0; x < decodedMask.width; x += 1) {\n                    const maskOffset = y * decodedMask.width + x;\n                    if (decodedMask.data[maskOffset]) {\n                        data[y * width + x] = detectionMaskId;\n                    }\n                }\n            }\n        }\n        return {\n            data,\n            fillPalette,\n            hasStroke,\n            height,\n            maxStrokeWidth,\n            strokePalette,\n            strokeWidths,\n            width,\n        };\n    }\n    function writePaletteEntry(palette, id, color, alpha) {\n        const offset = id * 4;\n        palette[offset] = ((color >> 16) & 0xff) / 255;\n        palette[offset + 1] = ((color >> 8) & 0xff) / 255;\n        palette[offset + 2] = (color & 0xff) / 255;\n        palette[offset + 3] = Math.max(0, Math.min(alpha, 1));\n    }\n\n    var MediaRendererFit;\n    (function (MediaRendererFit) {\n        /**\n         * Preserve media aspect ratio and fit the full frame inside the canvas.\n         */\n        MediaRendererFit[\"Contain\"] = \"contain\";\n        /**\n         * Preserve media aspect ratio and fill the canvas, cropping if necessary.\n         */\n        MediaRendererFit[\"Cover\"] = \"cover\";\n    })(MediaRendererFit || (MediaRendererFit = {}));\n    /**\n     * Playback lifecycle state reported by a platform renderer.\n     */\n    var MediaRendererPlaybackState;\n    (function (MediaRendererPlaybackState) {\n        MediaRendererPlaybackState[\"Loading\"] = \"loading\";\n        MediaRendererPlaybackState[\"Ready\"] = \"ready\";\n        MediaRendererPlaybackState[\"Playing\"] = \"playing\";\n        MediaRendererPlaybackState[\"Buffering\"] = \"buffering\";\n        MediaRendererPlaybackState[\"Paused\"] = \"paused\";\n        MediaRendererPlaybackState[\"Error\"] = \"error\";\n        MediaRendererPlaybackState[\"Destroyed\"] = \"destroyed\";\n    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));\n    /**\n     * Lower-level media source readiness.\n     */\n    var MediaSourceStatus;\n    (function (MediaSourceStatus) {\n        MediaSourceStatus[\"Loading\"] = \"loading\";\n        MediaSourceStatus[\"Ready\"] = \"ready\";\n        MediaSourceStatus[\"Error\"] = \"error\";\n        MediaSourceStatus[\"Destroyed\"] = \"destroyed\";\n    })(MediaSourceStatus || (MediaSourceStatus = {}));\n\n    /**\n     * Media-session operating mode.\n     *\n     * Core owns the names because file-like and stream-like lifecycle choices are\n     * platform-neutral. Platform packages decide how these modes tune media,\n     * storage, and renderer defaults.\n     */\n    var MediaSessionMode;\n    (function (MediaSessionMode) {\n        /**\n         * Finite media. Defaults usually favor seek/replay and persistent detection\n         * storage.\n         */\n        MediaSessionMode[\"File\"] = \"file\";\n        /**\n         * Live or append-only media. Defaults usually favor rolling windows and\n         * bounded retention.\n         */\n        MediaSessionMode[\"Stream\"] = \"stream\";\n    })(MediaSessionMode || (MediaSessionMode = {}));\n    /**\n     * Aggregate lifecycle state for a media session.\n     */\n    var MediaSessionStatus;\n    (function (MediaSessionStatus) {\n        MediaSessionStatus[\"Buffering\"] = \"buffering\";\n        MediaSessionStatus[\"Destroyed\"] = \"destroyed\";\n        MediaSessionStatus[\"Error\"] = \"error\";\n        MediaSessionStatus[\"Loading\"] = \"loading\";\n        MediaSessionStatus[\"Paused\"] = \"paused\";\n        MediaSessionStatus[\"Playing\"] = \"playing\";\n        MediaSessionStatus[\"Processing\"] = \"processing\";\n        MediaSessionStatus[\"Ready\"] = \"ready\";\n    })(MediaSessionStatus || (MediaSessionStatus = {}));\n    /**\n     * Subsystem currently affecting session readiness or presentation.\n     */\n    var MediaSessionActivityKind;\n    (function (MediaSessionActivityKind) {\n        MediaSessionActivityKind[\"DetectionsBuffering\"] = \"detectionsBuffering\";\n        MediaSessionActivityKind[\"DetectionsLoading\"] = \"detectionsLoading\";\n        MediaSessionActivityKind[\"Error\"] = \"error\";\n        MediaSessionActivityKind[\"MediaNormalizing\"] = \"mediaNormalizing\";\n        MediaSessionActivityKind[\"MediaOpening\"] = \"mediaOpening\";\n        MediaSessionActivityKind[\"PlaybackBuffering\"] = \"playbackBuffering\";\n        MediaSessionActivityKind[\"RenderPreparing\"] = \"renderPreparing\";\n    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));\n    /**\n     * State of one session activity.\n     */\n    var MediaSessionActivityStatus;\n    (function (MediaSessionActivityStatus) {\n        MediaSessionActivityStatus[\"Error\"] = \"error\";\n        MediaSessionActivityStatus[\"Running\"] = \"running\";\n        MediaSessionActivityStatus[\"Waiting\"] = \"waiting\";\n    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));\n\n    const PNG_SIGNATURE = new Uint8Array([\n        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,\n    ]);\n    function compositeMaskFrame(instructions) {\n        const maskInstructions = materializeMaskInstructions(instructions);\n        if (maskInstructions.length === 0) {\n            return undefined;\n        }\n        const width = Math.max(...maskInstructions.map(({ mask }) => mask.width));\n        const height = Math.max(...maskInstructions.map(({ mask }) => mask.height));\n        const data = new Uint8ClampedArray(new ArrayBuffer(width * height * 4));\n        for (const instruction of maskInstructions) {\n            compositeInstruction(data, width, instruction);\n        }\n        return { data, height, width };\n    }\n    function createMaskIdFrame(instructions) {\n        return createIdMaskFrame(materializeMaskInstructions(instructions));\n    }\n    async function createPngIdMaskFrame(instructions) {\n        const frame = createMaskIdFrame(instructions);\n        if (!frame) {\n            return undefined;\n        }\n        return {\n            ...frame,\n            png: await encodeGrayscalePng({\n                height: frame.height,\n                pixels: frame.data,\n                width: frame.width,\n            }),\n        };\n    }\n    function compositeInstruction(rgba, canvasWidth, instruction) {\n        const decodedMask = decodeCompressedRleMask(instruction.mask);\n        const fill = resolveRgbaColor(instruction.color, instruction.alpha);\n        compositeMaskFill(rgba, canvasWidth, decodedMask, fill);\n        if (instruction.stroke) {\n            compositeMaskStroke(rgba, canvasWidth, decodedMask, instruction.stroke);\n        }\n    }\n    function materializeMaskInstructions(instructions) {\n        return instructions.map((instruction) => {\n            if (instruction.mask) {\n                return instruction;\n            }\n            const { height, points, width } = instruction.polygon;\n            return {\n                alpha: instruction.alpha,\n                color: instruction.color,\n                detectionIndex: instruction.detectionIndex,\n                mask: encodeBinaryMask(rasterizePolygonToMask(points, { height, width }), width, height),\n                stroke: instruction.stroke,\n            };\n        });\n    }\n    function compositeMaskFill(rgba, canvasWidth, decodedMask, fill) {\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                const maskOffset = y * decodedMask.width + x;\n                if (!decodedMask.data[maskOffset]) {\n                    continue;\n                }\n                writePixel(rgba, canvasWidth, x, y, fill);\n            }\n        }\n    }\n    function compositeMaskStroke(rgba, canvasWidth, decodedMask, stroke) {\n        const width = Math.round(stroke.width);\n        if (width <= 0) {\n            return;\n        }\n        const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);\n        for (let y = 0; y < decodedMask.height; y += 1) {\n            for (let x = 0; x < decodedMask.width; x += 1) {\n                if (!isMaskPixel(decodedMask, x, y) ||\n                    !isBoundaryPixel(decodedMask, x, y)) {\n                    continue;\n                }\n                for (let offsetY = -width; offsetY <= width; offsetY += 1) {\n                    for (let offsetX = -width; offsetX <= width; offsetX += 1) {\n                        const strokeX = x + offsetX;\n                        const strokeY = y + offsetY;\n                        if (isOutsideMaskBounds(decodedMask, strokeX, strokeY) ||\n                            isMaskPixel(decodedMask, strokeX, strokeY)) {\n                            continue;\n                        }\n                        writePixel(rgba, canvasWidth, strokeX, strokeY, strokeColor);\n                    }\n                }\n            }\n        }\n    }\n    function isBoundaryPixel(mask, x, y) {\n        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {\n            for (let offsetX = -1; offsetX <= 1; offsetX += 1) {\n                if (offsetX === 0 && offsetY === 0) {\n                    continue;\n                }\n                const neighborX = x + offsetX;\n                const neighborY = y + offsetY;\n                if (isOutsideMaskBounds(mask, neighborX, neighborY) ||\n                    !isMaskPixel(mask, neighborX, neighborY)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    function isMaskPixel(mask, x, y) {\n        return mask.data[y * mask.width + x] === 1;\n    }\n    function isOutsideMaskBounds(mask, x, y) {\n        return x < 0 || y < 0 || x >= mask.width || y >= mask.height;\n    }\n    function resolveRgbaColor(color, alpha) {\n        return {\n            alpha: Math.round(Math.max(0, Math.min(alpha, 1)) * 255),\n            blue: color & 0xff,\n            green: (color >> 8) & 0xff,\n            red: (color >> 16) & 0xff,\n        };\n    }\n    function writePixel(rgba, canvasWidth, x, y, color) {\n        const rgbaOffset = (y * canvasWidth + x) * 4;\n        rgba[rgbaOffset] = color.red;\n        rgba[rgbaOffset + 1] = color.green;\n        rgba[rgbaOffset + 2] = color.blue;\n        rgba[rgbaOffset + 3] = color.alpha;\n    }\n    async function encodeGrayscalePng(options) {\n        if (typeof CompressionStream === \"undefined\") {\n            throw new Error(\"CompressionStream is required to encode PNG ID masks.\");\n        }\n        const rawScanlines = createFilterlessPngScanlines(options);\n        const ihdr = new Uint8Array(13);\n        const ihdrView = new DataView(ihdr.buffer);\n        ihdrView.setUint32(0, options.width);\n        ihdrView.setUint32(4, options.height);\n        ihdr[8] = 8;\n        ihdr[9] = 0;\n        ihdr[10] = 0;\n        ihdr[11] = 0;\n        ihdr[12] = 0;\n        const compressed = new Uint8Array(await new Response(new Blob([rawScanlines])\n            .stream()\n            .pipeThrough(new CompressionStream(\"deflate\"))).arrayBuffer());\n        return concatUint8Arrays([\n            PNG_SIGNATURE,\n            createPngChunk(\"IHDR\", ihdr),\n            createPngChunk(\"IDAT\", compressed),\n            createPngChunk(\"IEND\", new Uint8Array(0)),\n        ]);\n    }\n    function createFilterlessPngScanlines(options) {\n        const rowStride = options.width + 1;\n        const scanlines = new Uint8Array(rowStride * options.height);\n        for (let y = 0; y < options.height; y += 1) {\n            const sourceOffset = y * options.width;\n            const targetOffset = y * rowStride;\n            scanlines[targetOffset] = 0;\n            scanlines.set(options.pixels.subarray(sourceOffset, sourceOffset + options.width), targetOffset + 1);\n        }\n        return scanlines;\n    }\n    function createPngChunk(type, data) {\n        const typeBytes = new TextEncoder().encode(type);\n        const chunk = new Uint8Array(12 + data.length);\n        const view = new DataView(chunk.buffer);\n        view.setUint32(0, data.length);\n        chunk.set(typeBytes, 4);\n        chunk.set(data, 8);\n        view.setUint32(8 + data.length, crc32(concatUint8Arrays([typeBytes, data])));\n        return chunk;\n    }\n    const crc32Table = createCrc32Table();\n    function createCrc32Table() {\n        const table = new Uint32Array(256);\n        for (let index = 0; index < table.length; index += 1) {\n            let value = index;\n            for (let bit = 0; bit < 8; bit += 1) {\n                value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;\n            }\n            table[index] = value >>> 0;\n        }\n        return table;\n    }\n    function crc32(bytes) {\n        let crc = 0xffffffff;\n        for (const byte of bytes) {\n            crc = crc32Table[(crc ^ byte) & 0xff] ^ (crc >>> 8);\n        }\n        return (crc ^ 0xffffffff) >>> 0;\n    }\n    function concatUint8Arrays(chunks) {\n        const totalLength = chunks.reduce((total, chunk) => total + chunk.length, 0);\n        const result = new Uint8Array(totalLength);\n        let offset = 0;\n        for (const chunk of chunks) {\n            result.set(chunk, offset);\n            offset += chunk.length;\n        }\n        return result;\n    }\n\n    var PreparedMaskFrameKind;\n    (function (PreparedMaskFrameKind) {\n        PreparedMaskFrameKind[\"PngIdMask\"] = \"pngIdMask\";\n        PreparedMaskFrameKind[\"RgbaImage\"] = \"rgbaImage\";\n    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));\n\n    var MaskPreparationWorkerMessageType;\n    (function (MaskPreparationWorkerMessageType) {\n        MaskPreparationWorkerMessageType[\"Complete\"] = \"complete\";\n        MaskPreparationWorkerMessageType[\"Empty\"] = \"empty\";\n        MaskPreparationWorkerMessageType[\"Error\"] = \"error\";\n        MaskPreparationWorkerMessageType[\"Prepare\"] = \"prepare\";\n    })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));\n\n    const workerScope = globalThis;\n    workerScope.addEventListener(\"message\", (event) => {\n        const message = event.data;\n        if (message.type !== MaskPreparationWorkerMessageType.Prepare) {\n            return;\n        }\n        void prepareMaskFrame(message);\n    });\n    async function prepareMaskFrame(message) {\n        try {\n            const pngIdMaskFrame = await createPngIdMaskWorkerResponse(message);\n            if (pngIdMaskFrame) {\n                workerScope.postMessage(pngIdMaskFrame, [\n                    pngIdMaskFrame.imageBitmap,\n                    pngIdMaskFrame.png.buffer,\n                    pngIdMaskFrame.fillPalette.buffer,\n                    pngIdMaskFrame.strokePalette.buffer,\n                    pngIdMaskFrame.strokeWidths.buffer,\n                ]);\n                return;\n            }\n            const compositedFrame = compositeMaskFrame(message.job.instructions);\n            if (!compositedFrame) {\n                workerScope.postMessage({\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Empty,\n                });\n                return;\n            }\n            const imageData = new ImageData(compositedFrame.data, compositedFrame.width, compositedFrame.height);\n            const imageBitmap = createImageBitmapFromImageData(imageData);\n            const idMaskData = createMaskIdFrame(message.job.instructions)?.data;\n            if (imageBitmap) {\n                workerScope.postMessage({\n                    imageBitmap,\n                    idMaskData,\n                    key: message.job.key,\n                    requestId: message.requestId,\n                    type: MaskPreparationWorkerMessageType.Complete,\n                }, [...(idMaskData ? [idMaskData.buffer] : []), imageBitmap]);\n                return;\n            }\n            workerScope.postMessage({\n                idMaskData,\n                imageData,\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Complete,\n            }, [...(idMaskData ? [idMaskData.buffer] : []), imageData.data.buffer]);\n        }\n        catch (error) {\n            workerScope.postMessage({\n                error: error instanceof Error\n                    ? error.message\n                    : \"Unable to prepare mask frame.\",\n                key: message.job.key,\n                requestId: message.requestId,\n                type: MaskPreparationWorkerMessageType.Error,\n            });\n        }\n    }\n    async function createPngIdMaskWorkerResponse(message) {\n        if (typeof Blob === \"undefined\" ||\n            typeof createImageBitmap === \"undefined\" ||\n            typeof CompressionStream === \"undefined\") {\n            return undefined;\n        }\n        let frame;\n        try {\n            frame = await createPngIdMaskFrame(message.job.instructions);\n        }\n        catch {\n            return undefined;\n        }\n        if (!frame) {\n            return undefined;\n        }\n        let imageBitmap;\n        try {\n            imageBitmap = await createImageBitmap(new Blob([frame.png], { type: \"image/png\" }));\n        }\n        catch {\n            return undefined;\n        }\n        return {\n            artifactKind: PreparedMaskFrameKind.PngIdMask,\n            fillPalette: frame.fillPalette,\n            hasStroke: frame.hasStroke,\n            imageBitmap,\n            key: message.job.key,\n            maxStrokeWidth: frame.maxStrokeWidth,\n            png: frame.png,\n            requestId: message.requestId,\n            strokePalette: frame.strokePalette,\n            strokeWidths: frame.strokeWidths,\n            type: MaskPreparationWorkerMessageType.Complete,\n        };\n    }\n    function createImageBitmapFromImageData(imageData) {\n        if (typeof OffscreenCanvas === \"undefined\") {\n            return null;\n        }\n        const canvas = new OffscreenCanvas(imageData.width, imageData.height);\n        const context = canvas.getContext(\"2d\");\n        if (!context) {\n            return null;\n        }\n        context.putImageData(imageData, 0, 0);\n        return canvas.transferToImageBitmap();\n    }\n\n})();";
 
 const DEFAULT_WORKER_NAME = "supervision-js-render-preparation";
 let defaultWorkerUrl;
@@ -5361,85 +5964,6 @@ var MaskPreparationWorkerMessageType;
     MaskPreparationWorkerMessageType["Prepare"] = "prepare";
 })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));
 
-function createWorkerRpcClient(options) {
-    let failureMessage = null;
-    let isDestroyed = false;
-    let nextRequestId = 1;
-    const pendingRequests = new Map();
-    options.worker.addEventListener("message", (event) => {
-        handleWorkerMessage(event.data);
-    });
-    options.worker.addEventListener("error", (event) => {
-        rejectPendingRequests(event.message || options.defaultErrorMessage);
-    });
-    options.worker.addEventListener("messageerror", () => {
-        rejectPendingRequests(`${options.defaultErrorMessage}: message error.`);
-    });
-    return {
-        destroy() {
-            if (isDestroyed) {
-                return;
-            }
-            isDestroyed = true;
-            rejectPendingRequests("Worker RPC client has been destroyed.", {
-                markFailure: false,
-            });
-            options.worker.terminate();
-        },
-        getFailureMessage() {
-            return failureMessage;
-        },
-        request(message) {
-            if (isDestroyed) {
-                return Promise.reject(new Error("Worker RPC client has been destroyed."));
-            }
-            if (failureMessage) {
-                return Promise.reject(new Error(failureMessage));
-            }
-            const request = {
-                ...message,
-                requestId: nextRequestId,
-            };
-            nextRequestId += 1;
-            return new Promise((resolve, reject) => {
-                pendingRequests.set(request.requestId, { reject, resolve });
-                try {
-                    options.worker.postMessage(request);
-                }
-                catch (error) {
-                    pendingRequests.delete(request.requestId);
-                    failureMessage = getErrorMessage$2(error, options.defaultErrorMessage);
-                    reject(new Error(failureMessage));
-                }
-            });
-        },
-    };
-    function handleWorkerMessage(message) {
-        if (!options.isResponse(message)) {
-            return;
-        }
-        const pendingRequest = pendingRequests.get(message.requestId);
-        if (!pendingRequest) {
-            options.onOrphanedResponse?.(message);
-            return;
-        }
-        pendingRequests.delete(message.requestId);
-        pendingRequest.resolve(message);
-    }
-    function rejectPendingRequests(message, options = { markFailure: true }) {
-        if (options.markFailure) {
-            failureMessage = message;
-        }
-        for (const pendingRequest of pendingRequests.values()) {
-            pendingRequest.reject(new Error(message));
-        }
-        pendingRequests.clear();
-    }
-}
-function getErrorMessage$2(error, fallback) {
-    return error instanceof Error ? error.message : fallback;
-}
-
 function createMaskFramePreparer(options = {}) {
     const mainThreadPreparer = createMainThreadMaskFramePreparer(RenderPreparationWorkerStatus.Disabled);
     const mode = options.renderPreparation?.mode ?? RenderPreparationMode.Auto;
@@ -5573,6 +6097,7 @@ function createMainThreadMaskFramePreparer(workerStatus, message = null) {
                     canvas.height = 0;
                 },
                 height: compositedFrame.height,
+                idMaskData: createMaskIdFrame(job.instructions)?.data,
                 key: job.key,
                 kind: PreparedMaskFrameKind.RgbaImage,
                 source: canvas,
@@ -5747,6 +6272,7 @@ function createPreparedFrameFromWorkerResponse(message) {
                 message.imageBitmap?.close();
             },
             height: message.imageBitmap.height,
+            idMaskData: message.idMaskData,
             key: message.key,
             kind: PreparedMaskFrameKind.RgbaImage,
             source: message.imageBitmap,
@@ -5770,6 +6296,7 @@ function createPreparedFrameFromWorkerResponse(message) {
             canvas.height = 0;
         },
         height: message.imageData.height,
+        idMaskData: message.idMaskData,
         key: message.key,
         kind: PreparedMaskFrameKind.RgbaImage,
         source: canvas,
@@ -6638,7 +7165,7 @@ function createPixiIdMaskShaderRenderer(options) {
         autoGenerateMipmaps: false,
         dynamic: false,
         height: 1,
-        resource: createPlaceholderCanvas(),
+        resource: createPlaceholderCanvas$1(),
         scaleMode: "nearest",
         width: 1,
     });
@@ -6728,7 +7255,7 @@ function createPixiIdMaskShaderRenderer(options) {
         mesh.shader = shader;
     }
 }
-function createPlaceholderCanvas() {
+function createPlaceholderCanvas$1() {
     const canvas = document.createElement("canvas");
     canvas.height = 1;
     canvas.width = 1;
@@ -6878,15 +7405,219 @@ void main(void) {
 }
 `;
 
+/**
+ * Renders blurred, per-detection-colored copies of the prepared id mask
+ * beneath the mask layer. Each pass maps mask ids through a halo palette and
+ * a GPU blur filter turns that coverage into a smooth glow following the
+ * exact mask silhouette, reusing the already-prepared mask texture. Passes
+ * are pooled and one runs per distinct spread.
+ */
+function createPixiMaskHaloRenderer(options) {
+    const display = new options.Container();
+    const placeholderSource = new options.ImageSource({
+        autoGenerateMipmaps: false,
+        dynamic: false,
+        height: 1,
+        resource: createPlaceholderCanvas(),
+        scaleMode: "nearest",
+        width: 1,
+    });
+    const geometry = new options.MeshGeometry({
+        indices: new Uint32Array([0, 1, 2, 0, 2, 3]),
+        positions: new Float32Array([
+            0,
+            0,
+            options.mediaWidth,
+            0,
+            options.mediaWidth,
+            options.mediaHeight,
+            0,
+            options.mediaHeight,
+        ]),
+        shrinkBuffersToFit: true,
+        topology: "triangle-list",
+        uvs: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
+    });
+    const passes = [];
+    display.visible = false;
+    return {
+        destroy() {
+            for (const pass of passes) {
+                pass.mesh.destroy();
+                pass.shader.destroy(true);
+            }
+            passes.length = 0;
+            display.destroy();
+            geometry.destroy();
+            placeholderSource.destroy();
+        },
+        display,
+        hide() {
+            display.visible = false;
+        },
+        render(frame, texture, groups) {
+            if (groups.length === 0) {
+                display.visible = false;
+                return;
+            }
+            for (const [index, group] of groups.entries()) {
+                const pass = ensurePass(index);
+                bindTexture(pass, texture.source);
+                pass.uniforms.uniforms.uHaloPalette = group.palette;
+                pass.uniforms.update();
+                pass.blurFilter.strength = Math.max(group.spread, 0);
+                pass.mesh.visible = true;
+            }
+            for (const pass of passes.slice(groups.length)) {
+                pass.mesh.visible = false;
+            }
+            display.visible = true;
+        },
+        setOpacity(opacity) {
+            display.alpha = opacity;
+        },
+    };
+    function ensurePass(index) {
+        const existing = passes[index];
+        if (existing) {
+            return existing;
+        }
+        const uniforms = new options.UniformGroup({
+            uHaloPalette: {
+                size: MAX_ID_MASK_PALETTE_ENTRIES,
+                type: "vec4<f32>",
+                value: new Float32Array(MAX_ID_MASK_PALETTE_ENTRIES * 4),
+            },
+        });
+        const shader = createShader(uniforms);
+        const mesh = new options.Mesh({ geometry, shader });
+        const blurFilter = new options.BlurFilter({ quality: 4, strength: 8 });
+        // Filters size their working texture from measured bounds, and a
+        // custom-geometry mesh measures empty; an explicit bounds area keeps the
+        // blur pass covering the full media rect.
+        mesh.boundsArea = new options.Rectangle(0, 0, options.mediaWidth, options.mediaHeight);
+        mesh.filters = [blurFilter];
+        display.addChild(mesh);
+        const pass = { blurFilter, mesh, shader, uniforms };
+        passes.push(pass);
+        return pass;
+    }
+    function bindTexture(pass, source) {
+        try {
+            pass.shader.resources.uTexture = source;
+            pass.shader.resources.uSampler = source.style;
+        }
+        catch {
+            try {
+                pass.shader.destroy(true);
+            }
+            catch {
+                // Pixi has already invalidated this shader's resource group.
+            }
+            pass.shader = createShader(pass.uniforms);
+            pass.mesh.shader = pass.shader;
+            pass.shader.resources.uTexture = source;
+            pass.shader.resources.uSampler = source.style;
+        }
+    }
+    function createShader(uniforms) {
+        return options.Shader.from({
+            gl: {
+                fragment: maskHaloFragmentShader,
+                vertex: maskHaloVertexShader,
+            },
+            resources: {
+                haloUniforms: uniforms,
+                uSampler: placeholderSource.style,
+                uTexture: placeholderSource,
+            },
+        });
+    }
+}
+/**
+ * Builds one halo palette uniform: premultiplied halo color and alpha per
+ * mask id, transparent for ids outside the group.
+ */
+function buildMaskHaloPalette(halos) {
+    const palette = new Float32Array(MAX_ID_MASK_PALETTE_ENTRIES * 4);
+    for (const [maskId, halo] of halos) {
+        if (maskId <= 0 || maskId >= MAX_ID_MASK_PALETTE_ENTRIES) {
+            continue;
+        }
+        const alpha = Math.max(0, Math.min(halo.alpha, 1));
+        const offset = maskId * 4;
+        palette[offset] = (((halo.color >> 16) & 0xff) / 255) * alpha;
+        palette[offset + 1] = (((halo.color >> 8) & 0xff) / 255) * alpha;
+        palette[offset + 2] = ((halo.color & 0xff) / 255) * alpha;
+        palette[offset + 3] = alpha;
+    }
+    return palette;
+}
+function createPlaceholderCanvas() {
+    const canvas = document.createElement("canvas");
+    canvas.height = 1;
+    canvas.width = 1;
+    return canvas;
+}
+const maskHaloVertexShader = `#version 300 es
+precision highp float;
+
+in vec2 aPosition;
+in vec2 aUV;
+
+uniform mat3 uProjectionMatrix;
+uniform mat3 uWorldTransformMatrix;
+uniform vec4 uWorldColorAlpha;
+uniform mat3 uTransformMatrix;
+uniform vec4 uColor;
+
+out vec2 vUV;
+out vec4 vColor;
+
+void main(void) {
+  mat3 modelViewProjectionMatrix =
+    uProjectionMatrix * uWorldTransformMatrix * uTransformMatrix;
+
+  gl_Position =
+    vec4((modelViewProjectionMatrix * vec3(aPosition, 1.0)).xy, 0.0, 1.0);
+  vUV = aUV;
+  vColor = uWorldColorAlpha * uColor;
+}
+`;
+const maskHaloFragmentShader = `#version 300 es
+precision highp float;
+precision highp int;
+
+in vec2 vUV;
+in vec4 vColor;
+
+uniform sampler2D uTexture;
+uniform vec4 uHaloPalette[${MAX_ID_MASK_PALETTE_ENTRIES}];
+
+out vec4 finalColor;
+
+void main(void) {
+  float maskId = floor(texture(uTexture, vUV).r * 255.0 + 0.5);
+  int paletteIndex =
+    int(clamp(maskId, 0.0, float(${MAX_ID_MASK_PALETTE_ENTRIES - 1})));
+
+  finalColor = uHaloPalette[paletteIndex] * vColor;
+}
+`;
+
 const MAX_PENDING_MASK_HOLD_SECONDS = 0.05;
 function createPixiMaskLayer(options) {
     let mediaHeight = 0;
     let mediaWidth = 0;
     let idMaskRenderer;
+    let haloRenderer;
+    let currentMaskHaloStyle = options.maskHaloStyle ?? null;
+    options.maskStyle;
     let maskSprite;
     let activeFrameKey = null;
     let activeFrameMediaTime = null;
     let activeIdMaskFrame = null;
+    let activeRgbaMaskFrame = null;
     let maskOpacity = resolveMaskStyleOpacity(options.maskStyle);
     let maskPickCanvas;
     let maskPickContext;
@@ -6894,6 +7625,7 @@ function createPixiMaskLayer(options) {
     let visibleMaskMediaTime = null;
     let isDestroyed = false;
     const maskTextures = new Map();
+    const haloTextures = new Map();
     const preparedRenderWindow = createPreparedRenderWindow({
         artifactKind: options.artifactKind,
         detectionTimeline: options.detectionTimeline,
@@ -6939,10 +7671,19 @@ function createPixiMaskLayer(options) {
             maskSprite.height = mediaHeight;
             idMaskRenderer = createIdMaskRenderer();
             idMaskRenderer?.setOpacity(maskOpacity);
+            haloRenderer = createHaloRenderer();
+            // Halo alpha is resolved from MaskHaloStyle per detection. It must not
+            // inherit the independent mask renderer's global opacity.
+            haloRenderer?.setOpacity(1);
             if (!idMaskRenderer || !options.Container) {
                 return maskSprite;
             }
             const maskContainer = new options.Container();
+            // The halo draws beneath the mask so the glow bleeds outward from the
+            // silhouette while fills and borders stay crisp on top.
+            if (haloRenderer) {
+                maskContainer.addChild(haloRenderer.display);
+            }
             maskContainer.addChild(maskSprite, idMaskRenderer.mesh);
             return maskContainer;
         },
@@ -6952,6 +7693,7 @@ function createPixiMaskLayer(options) {
                 activeFrameKey = preparedFrame?.key ?? null;
                 activeFrameMediaTime = preparedFrame?.detectionFrame.mediaTime ?? null;
                 activeIdMaskFrame = null;
+                activeRgbaMaskFrame = null;
                 hideSprite();
                 return;
             }
@@ -6964,6 +7706,7 @@ function createPixiMaskLayer(options) {
             if (preparedFrame.maskStatus === PreparedRenderFrameMaskStatus.Empty ||
                 preparedFrame.maskStatus === PreparedRenderFrameMaskStatus.Disabled) {
                 activeIdMaskFrame = null;
+                activeRgbaMaskFrame = null;
                 hideSprite();
                 return;
             }
@@ -7016,6 +7759,14 @@ function createPixiMaskLayer(options) {
                 applyMaskOpacity();
             }
             preparedRenderWindow.setMaskStyle(nextMaskStyle);
+            refreshHalo();
+        },
+        setMaskHaloStyle(nextMaskHaloStyle) {
+            if (nextMaskHaloStyle === undefined) {
+                return;
+            }
+            currentMaskHaloStyle = nextMaskHaloStyle;
+            refreshHalo();
         },
         destroy() {
             if (isDestroyed) {
@@ -7026,17 +7777,22 @@ function createPixiMaskLayer(options) {
             destroyTextures();
             resetMaskPickCanvas();
             idMaskRenderer?.destroy();
+            haloRenderer?.destroy();
         },
     };
     function showMaskFrame(maskFrame, mediaTime) {
         visibleMaskMediaTime = mediaTime;
         activeIdMaskFrame =
             maskFrame.kind === PreparedMaskFrameKind.PngIdMask ? maskFrame : null;
+        activeRgbaMaskFrame =
+            maskFrame.kind === PreparedMaskFrameKind.RgbaImage ? maskFrame : null;
         if (maskFrame.kind === PreparedMaskFrameKind.PngIdMask && idMaskRenderer) {
             showIdMaskFrame(maskFrame);
             return;
         }
-        showRgbaMaskFrame(maskFrame);
+        if (maskFrame.kind === PreparedMaskFrameKind.RgbaImage) {
+            showRgbaMaskFrame(maskFrame);
+        }
     }
     function getTexture(maskFrame) {
         const existingTexture = maskTextures.get(maskFrame.key);
@@ -7060,6 +7816,40 @@ function createPixiMaskLayer(options) {
         maskTextures.set(maskFrame.key, texture);
         return texture;
     }
+    function getHaloTexture(maskFrame) {
+        const existingTexture = haloTextures.get(maskFrame.key);
+        if (existingTexture) {
+            return existingTexture;
+        }
+        if (!maskFrame.idMaskData || typeof document === "undefined") {
+            return undefined;
+        }
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!context || typeof context.createImageData !== "function") {
+            return undefined;
+        }
+        canvas.width = maskFrame.width;
+        canvas.height = maskFrame.height;
+        const imageData = context.createImageData(maskFrame.width, maskFrame.height);
+        for (let index = 0; index < maskFrame.idMaskData.length; index += 1) {
+            const offset = index * 4;
+            imageData.data[offset] = maskFrame.idMaskData[index];
+            imageData.data[offset + 3] = 255;
+        }
+        context.putImageData(imageData, 0, 0);
+        const source = new options.ImageSource({
+            autoGenerateMipmaps: false,
+            dynamic: false,
+            height: maskFrame.height,
+            resource: canvas,
+            scaleMode: "nearest",
+            width: maskFrame.width,
+        });
+        const texture = new options.Texture({ dynamic: false, source });
+        haloTextures.set(maskFrame.key, texture);
+        return texture;
+    }
     function showRgbaMaskFrame(maskFrame) {
         if (!maskSprite) {
             return;
@@ -7071,6 +7861,13 @@ function createPixiMaskLayer(options) {
         maskSprite.height = mediaHeight;
         maskSprite.visible = true;
         idMaskRenderer?.hide();
+        const haloTexture = getHaloTexture(maskFrame);
+        if (haloTexture) {
+            renderHalo(maskFrame, haloTexture);
+        }
+        else {
+            haloRenderer?.hide();
+        }
     }
     function showIdMaskFrame(maskFrame) {
         if (!idMaskRenderer || !maskSprite) {
@@ -7078,14 +7875,82 @@ function createPixiMaskLayer(options) {
         }
         maskSprite.visible = false;
         idMaskRenderer.render(maskFrame, getTexture(maskFrame));
+        renderHalo(maskFrame, getTexture(maskFrame));
+    }
+    function renderHalo(maskFrame, texture) {
+        if (!haloRenderer) {
+            return;
+        }
+        const groups = resolveFrameHaloGroups();
+        if (groups.length === 0) {
+            haloRenderer.hide();
+            return;
+        }
+        haloRenderer.render(maskFrame, texture, groups);
+    }
+    function refreshHalo() {
+        if (activeIdMaskFrame) {
+            renderHalo(activeIdMaskFrame, getTexture(activeIdMaskFrame));
+            return;
+        }
+        if (activeRgbaMaskFrame) {
+            const texture = getHaloTexture(activeRgbaMaskFrame);
+            if (texture) {
+                renderHalo(activeRgbaMaskFrame, texture);
+            }
+        }
+    }
+    /**
+     * Halo instructions resolve per frame from the live halo style rather than
+     * being baked into the prepared artifact, so halo edits never invalidate
+     * prepared mask pixels. Detections are grouped by their requested spread
+     * and every group renders in its own blur pass, preserving each
+     * detection's public spread contract.
+     */
+    function resolveFrameHaloGroups() {
+        if (visibleMaskMediaTime === null || !currentMaskHaloStyle) {
+            return [];
+        }
+        const frame = options.detectionTimeline.selectFrame(visibleMaskMediaTime);
+        if (!frame) {
+            return [];
+        }
+        const bySpread = new Map();
+        for (const [detectionIndex, detection] of frame.detections.entries()) {
+            if (!detection.mask) {
+                continue;
+            }
+            const halo = currentMaskHaloStyle.resolve(detection, {
+                detectionIndex,
+                frame,
+                mediaTime: visibleMaskMediaTime,
+            });
+            if (!halo || halo.alpha <= 0 || halo.spread <= 0) {
+                continue;
+            }
+            let group = bySpread.get(halo.spread);
+            if (!group) {
+                group = new Map();
+                bySpread.set(halo.spread, group);
+            }
+            group.set(detectionIndex + 1, { alpha: halo.alpha, color: halo.color });
+        }
+        return [...bySpread.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([spread, halos]) => ({
+            palette: buildMaskHaloPalette(halos),
+            spread,
+        }));
     }
     function hideSprite() {
         visibleMaskMediaTime = null;
         activeIdMaskFrame = null;
+        activeRgbaMaskFrame = null;
         if (maskSprite) {
             maskSprite.visible = false;
         }
         idMaskRenderer?.hide();
+        haloRenderer?.hide();
     }
     function canHoldVisibleMaskFor(mediaTime) {
         return (visibleMaskMediaTime !== null &&
@@ -7101,11 +7966,21 @@ function createPixiMaskLayer(options) {
     function destroyTexture(key) {
         const texture = maskTextures.get(key);
         if (!texture) {
+            destroyHaloTexture(key);
             return;
         }
         releaseTextureBindings(key, texture);
         maskTextures.delete(key);
         texture.destroy(true);
+        destroyHaloTexture(key);
+    }
+    function destroyHaloTexture(key) {
+        const texture = haloTextures.get(key);
+        if (!texture) {
+            return;
+        }
+        haloTextures.delete(key);
+        texture.destroy(true);
     }
     function destroyTextures() {
         releaseTextureBindings();
@@ -7113,6 +7988,10 @@ function createPixiMaskLayer(options) {
             texture.destroy(true);
         }
         maskTextures.clear();
+        for (const texture of haloTextures.values()) {
+            texture.destroy(true);
+        }
+        haloTextures.clear();
     }
     function releaseTextureBindings(key, texture) {
         if (!texture || maskSprite?.texture === texture) {
@@ -7124,6 +8003,31 @@ function createPixiMaskLayer(options) {
             idMaskRenderer?.clearTexture();
         }
     }
+    function createHaloRenderer() {
+        if (!options.BlurFilter ||
+            !options.Container ||
+            !options.Rectangle ||
+            !options.Mesh ||
+            !options.MeshGeometry ||
+            !options.Shader ||
+            !options.UniformGroup ||
+            mediaWidth <= 0 ||
+            mediaHeight <= 0) {
+            return undefined;
+        }
+        return createPixiMaskHaloRenderer({
+            BlurFilter: options.BlurFilter,
+            Container: options.Container,
+            Rectangle: options.Rectangle,
+            ImageSource: options.ImageSource,
+            Mesh: options.Mesh,
+            MeshGeometry: options.MeshGeometry,
+            Shader: options.Shader,
+            UniformGroup: options.UniformGroup,
+            mediaHeight,
+            mediaWidth,
+        });
+    }
     function createIdMaskRenderer() {
         if (!options.Mesh ||
             !options.MeshGeometry ||
@@ -7324,6 +8228,9 @@ function canPreparePolygonInstruction(instruction) {
     return (instruction.points.length >= 3 &&
         Boolean(instruction.fill || stroke) &&
         !stroke?.dash?.length &&
+        stroke?.cap === undefined &&
+        stroke?.join === undefined &&
+        stroke?.miterLimit === undefined &&
         (stroke?.alignment === undefined ||
             stroke.alignment === BoxStrokeAlignment.Center));
 }
@@ -7368,6 +8275,367 @@ function resolvePreparedPolygonInstructions(options) {
     return instructions;
 }
 
+const sharedAssets = new WeakMap();
+/** Browser implementation for asset-backed region renderer descriptors. */
+function createPixiRegionLayer(options) {
+    let container;
+    let currentFrame;
+    let currentMediaTime = 0;
+    let currentViewportScale = 1;
+    let destroyed = false;
+    let renderers = [...options.regionRenderers];
+    const assets = new Map();
+    const entries = new Map();
+    const pools = new Map();
+    syncAssets();
+    return {
+        createContainer() {
+            if (!container) {
+                container = new options.Container();
+                container.sortableChildren = true;
+            }
+            return container;
+        },
+        drawFrame(mediaTime, viewportScale = 1) {
+            currentMediaTime = mediaTime;
+            currentViewportScale = viewportScale;
+            currentFrame = options.detectionTimeline.selectFrame(mediaTime);
+            const activeKeys = new Set();
+            const activeDetectionIndexes = new Set();
+            for (const entry of entries.values())
+                entry.active = false;
+            if (currentFrame) {
+                for (const [rendererIndex, renderer] of renderers.entries()) {
+                    const asset = assets.get(renderer.id);
+                    if (!asset?.asset)
+                        continue;
+                    for (const [detectionIndex, detection,] of currentFrame.detections.entries()) {
+                        const context = {
+                            detectionIndex,
+                            frame: currentFrame,
+                            mediaTime,
+                            viewportScale,
+                            ...options.resolveContextState?.(detection),
+                        };
+                        if (context.hidden ||
+                            !matchesTarget(renderer, detection, context)) {
+                            continue;
+                        }
+                        const region = resolveRegion(renderer, detection);
+                        if (!region)
+                            continue;
+                        const key = resolveSpriteKey(renderer.id, detection, detectionIndex);
+                        const entry = ensureEntry(key, renderer.id, asset.src, asset.asset, detection.id);
+                        const position = positionSprite(entry.display, renderer, region, asset.asset);
+                        entry.baseX = position.x;
+                        entry.baseY = position.y;
+                        entry.detectionId = detection.id;
+                        entry.display.zIndex =
+                            (renderer.compose?.zIndex ?? 0) * 1_000_000 +
+                                rendererIndex * 10_000 +
+                                (detection.zIndex ?? detectionIndex);
+                        entry.display.visible = true;
+                        entry.active = true;
+                        activeKeys.add(key);
+                        activeDetectionIndexes.add(detectionIndex);
+                    }
+                }
+            }
+            for (const [key, entry] of entries) {
+                if (activeKeys.has(key))
+                    continue;
+                entry.display.visible = false;
+                pauseAnimatedDisplay(entry.display);
+                entries.delete(key);
+                const poolKey = resolvePoolKey(entry.rendererId, entry.src);
+                const pool = pools.get(poolKey) ?? [];
+                pool.push(entry);
+                pools.set(poolKey, pool);
+            }
+            return { activeDetectionIndexes: [...activeDetectionIndexes] };
+        },
+        setRenderers(nextRenderers) {
+            renderers = [...nextRenderers];
+            syncAssets();
+            this.drawFrame(currentMediaTime, currentViewportScale);
+        },
+        translateDetection(id, x, y) {
+            let translated = false;
+            for (const entry of entries.values()) {
+                if (!entry.active || entry.detectionId !== id)
+                    continue;
+                entry.display.position.set(entry.baseX + x, entry.baseY + y);
+                translated = true;
+            }
+            return translated;
+        },
+        destroy() {
+            destroyed = true;
+            destroyAllDisplays();
+            for (const asset of assets.values())
+                asset.lease.release();
+            assets.clear();
+            container = undefined;
+            currentFrame = undefined;
+        },
+    };
+    function syncAssets() {
+        const desired = new Map(renderers.map((renderer) => [renderer.id, renderer.source.asset.src]));
+        for (const [id, asset] of assets) {
+            if (desired.get(id) === asset.src)
+                continue;
+            destroyRendererDisplays(id);
+            asset.lease.release();
+            assets.delete(id);
+        }
+        for (const [id, src] of desired) {
+            if (assets.has(id))
+                continue;
+            const lease = acquireAsset(options.Assets, src);
+            const asset = { lease, src };
+            assets.set(id, asset);
+            void lease.asset.then((loadedAsset) => {
+                if (destroyed || assets.get(id) !== asset)
+                    return;
+                asset.asset = loadedAsset;
+                options.onInvalidate?.();
+            }, (error) => {
+                // A failed asset is omitted. Replacing the descriptor retries it.
+                options.onAssetError?.({ error, rendererId: id, src });
+            });
+        }
+    }
+    function ensureEntry(key, rendererId, src, asset, detectionId) {
+        let entry = entries.get(key);
+        if (entry)
+            return entry;
+        const poolKey = resolvePoolKey(rendererId, src);
+        const pool = pools.get(poolKey);
+        entry = pool?.pop();
+        if (pool?.length === 0)
+            pools.delete(poolKey);
+        if (entry) {
+            entry.detectionId = detectionId;
+            resumeAnimatedDisplay(entry.display);
+        }
+        else {
+            const display = isGifSource(asset)
+                ? new options.GifSprite({ autoPlay: true, loop: true, source: asset })
+                : new options.Sprite({ texture: asset });
+            display.anchor.set(0.5);
+            container?.addChild(display);
+            entry = {
+                active: false,
+                baseX: 0,
+                baseY: 0,
+                detectionId,
+                display,
+                rendererId,
+                src,
+            };
+        }
+        entries.set(key, entry);
+        return entry;
+    }
+    function destroyRendererDisplays(rendererId) {
+        for (const [key, entry] of entries) {
+            if (entry.rendererId !== rendererId)
+                continue;
+            destroyDisplay(entry.display);
+            entries.delete(key);
+        }
+        for (const [key, pool] of pools) {
+            const retained = pool.filter((entry) => {
+                if (entry.rendererId !== rendererId)
+                    return true;
+                destroyDisplay(entry.display);
+                return false;
+            });
+            if (retained.length > 0)
+                pools.set(key, retained);
+            else
+                pools.delete(key);
+        }
+    }
+    function destroyAllDisplays() {
+        for (const entry of entries.values())
+            destroyDisplay(entry.display);
+        for (const pool of pools.values()) {
+            for (const entry of pool)
+                destroyDisplay(entry.display);
+        }
+        entries.clear();
+        pools.clear();
+    }
+}
+function destroyDisplay(display) {
+    display.removeFromParent?.();
+    // GifSprite sources are shared and released through Assets.unload().
+    display.destroy();
+}
+function pauseAnimatedDisplay(display) {
+    if ("stop" in display && typeof display.stop === "function")
+        display.stop();
+}
+function resumeAnimatedDisplay(display) {
+    if ("play" in display && typeof display.play === "function")
+        display.play();
+}
+function matchesTarget(renderer, detection, context) {
+    const { target } = renderer;
+    return (matchesValue(target.id, detection.id) &&
+        matchesValue(target.className, detection.className) &&
+        matchesValue(target.sourceId, detection.sourceId) &&
+        (target.resolve?.(detection, context) ?? true));
+}
+function matchesValue(configured, actual) {
+    if (configured === undefined)
+        return true;
+    if (actual === undefined)
+        return false;
+    return Array.isArray(configured)
+        ? configured.includes(actual)
+        : configured === actual;
+}
+function resolveRegion(renderer, detection) {
+    if (renderer.region.kind === "bounds")
+        return detection.rect;
+    const fallbackSize = detection.rect
+        ? Math.max(1, detection.rect.width * 0.4)
+        : undefined;
+    if (renderer.region.anchor === "head") {
+        const facePoints = detection.keypoints?.points
+            .slice(0, 5)
+            .filter((_, index) => (detection.keypoints?.visibility?.[index] ?? 2) > 0);
+        if (facePoints && facePoints.length > 0) {
+            const xs = facePoints.map(({ x }) => x);
+            const ys = facePoints.map(({ y }) => y);
+            const width = Math.max(fallbackSize ?? 1, (Math.max(...xs) - Math.min(...xs)) * 2);
+            return {
+                height: width,
+                width,
+                x: xs.reduce((sum, x) => sum + x, 0) / xs.length,
+                y: ys.reduce((sum, y) => sum + y, 0) / ys.length,
+            };
+        }
+        if (!detection.rect || fallbackSize === undefined)
+            return undefined;
+        return {
+            height: fallbackSize,
+            width: fallbackSize,
+            x: detection.rect.x,
+            y: detection.rect.y - detection.rect.height / 2,
+        };
+    }
+    const point = detection.keypoints?.points[renderer.region.anchor];
+    const visibility = detection.keypoints?.visibility?.[renderer.region.anchor] ?? 2;
+    if (!point || visibility <= 0 || fallbackSize === undefined)
+        return undefined;
+    return { height: fallbackSize, width: fallbackSize, x: point.x, y: point.y };
+}
+function positionSprite(sprite, renderer, region, asset) {
+    const scale = finiteOr(renderer.transform?.scale, 1);
+    const opacity = Math.min(1, Math.max(0, finiteOr(renderer.transform?.opacity, 1)));
+    const sourceWidth = Math.max(1, asset.width);
+    const sourceHeight = Math.max(1, asset.height);
+    const containScale = Math.min(region.width / sourceWidth, region.height / sourceHeight);
+    const offset = renderer.transform?.offset;
+    sprite.alpha = opacity;
+    sprite.width = sourceWidth * containScale * scale;
+    sprite.height = sourceHeight * containScale * scale;
+    const position = {
+        x: region.x + finiteOr(offset?.x, 0) * region.width,
+        y: region.y + finiteOr(offset?.y, 0) * region.height,
+    };
+    sprite.position.set(position.x, position.y);
+    sprite.rotation = finiteOr(renderer.transform?.rotation, 0);
+    return position;
+}
+function isGifSource(asset) {
+    return ("totalFrames" in asset && "frames" in asset && Array.isArray(asset.frames));
+}
+function resolvePoolKey(rendererId, src) {
+    return JSON.stringify([rendererId, src]);
+}
+function resolveSpriteKey(rendererId, detection, detectionIndex) {
+    return JSON.stringify([rendererId, detection.id ?? null, detectionIndex]);
+}
+function finiteOr(value, fallback) {
+    return value !== undefined && Number.isFinite(value) ? value : fallback;
+}
+function acquireAsset(loader, src) {
+    let cache = sharedAssets.get(loader);
+    if (!cache) {
+        cache = new Map();
+        sharedAssets.set(loader, cache);
+    }
+    let entry = cache.get(src);
+    if (!entry) {
+        entry = { asset: loader.load(src), references: 0 };
+        cache.set(src, entry);
+    }
+    entry.references += 1;
+    let released = false;
+    return {
+        release() {
+            if (released)
+                return;
+            released = true;
+            entry.references -= 1;
+            if (entry.references > 0)
+                return;
+            cache.delete(src);
+            void entry.asset.then(() => loader.unload(src), () => undefined);
+        },
+        asset: entry.asset,
+    };
+}
+
+/**
+ * Bridges public annotation renderer kinds onto the internal vector-layer
+ * shape pipeline.
+ *
+ * Each shape-backed renderer kind resolves its own public instruction per
+ * detection; this adapter lowers those instructions into the internal
+ * renderer-neutral shape vocabulary and concatenates them into the single
+ * shape style the vector layer consumes. Kinds stay independent: a kind that
+ * resolves nothing for a detection simply contributes no instructions.
+ */
+function resolveAnnotationShapeStyle(styles) {
+    const boxCornerStyle = styles.boxCornerStyle ?? null;
+    const ellipseStyle = styles.ellipseStyle ?? null;
+    const markerStyle = styles.markerStyle ?? null;
+    if (!boxCornerStyle && !ellipseStyle && !markerStyle) {
+        return null;
+    }
+    return {
+        resolve(detection, context) {
+            const instructions = [];
+            const boxCorners = boxCornerStyle?.resolve(detection, context);
+            if (boxCorners) {
+                instructions.push({
+                    closed: false,
+                    kind: ShapeInstructionKind.Path,
+                    segments: boxCorners.segments,
+                    stroke: boxCorners.stroke,
+                });
+            }
+            const marker = markerStyle?.resolve(detection, context);
+            if (marker) {
+                instructions.push({ kind: ShapeInstructionKind.Marker, ...marker });
+            }
+            const ellipse = ellipseStyle?.resolve(detection, context);
+            if (ellipse) {
+                instructions.push(lowerEllipseInstruction(ellipse));
+            }
+            return instructions.length > 0 ? instructions : undefined;
+        },
+    };
+}
+function lowerEllipseInstruction(instruction) {
+    return { ...instruction, kind: ShapeInstructionKind.Ellipse };
+}
+
 function createPixiAnnotationOverlayLayer(editingEngine, initialStyle) {
     let graphics;
     let style = resolveAnnotationOverlayStyle(initialStyle);
@@ -7600,8 +8868,11 @@ function drawLoading(graphics, context, style) {
     const loading = values instanceof Set ? values : new Set(values);
     const angle = (context.now / 500) % (Math.PI * 2);
     for (const detection of context.frame?.detections ?? []) {
-        if (detection.id === undefined || !loading.has(detection.id))
+        if (detection.id === undefined ||
+            !loading.has(detection.id) ||
+            resolveAnnotationStyleState(detection, context.visibility).hidden) {
             continue;
+        }
         const rect = getDetectionRect(detection);
         if (!rect)
             continue;
@@ -7676,6 +8947,7 @@ var PixiSceneLayerKind;
     PixiSceneLayerKind["Mask"] = "mask";
     PixiSceneLayerKind["Box"] = "box";
     PixiSceneLayerKind["Vector"] = "vector";
+    PixiSceneLayerKind["Region"] = "region";
     PixiSceneLayerKind["Focus"] = "focus";
     PixiSceneLayerKind["Preview"] = "preview";
     PixiSceneLayerKind["Guide"] = "guide";
@@ -7720,6 +8992,8 @@ function defaultLayerOrder(kind) {
             return 200;
         case PixiSceneLayerKind.Vector:
             return 250;
+        case PixiSceneLayerKind.Region:
+            return 275;
         case PixiSceneLayerKind.Focus:
             return 300;
         case PixiSceneLayerKind.Preview:
@@ -7775,14 +9049,42 @@ function observePixiContainerResize(container, resize) {
     return () => observer.disconnect();
 }
 async function createPixiMediaScene(options) {
-    const { Application, CanvasSource, Container, Graphics, ImageSource, Mesh, MeshGeometry, Rectangle, Sprite, Shader, Text, Texture, UniformGroup, } = await import('pixi.js');
+    const { Application, Assets, BlurFilter, CanvasSource, Container, Graphics, ImageSource, Mesh, MeshGeometry, Rectangle, Sprite, Shader, Text, Texture, UniformGroup, } = await import('pixi.js');
+    const { GifSprite } = await import('pixi.js/gif');
     const app = new Application();
+    let currentEllipseStyle = options.ellipseStyle ?? null;
+    let currentBoxCornerStyle = options.boxCornerStyle ?? null;
     let currentLabelStyle = options.labelStyle ?? null;
     let currentMaskStyle = options.maskStyle ?? null;
+    let currentMarkerStyle = options.markerStyle ?? null;
+    let currentMaskHaloStyle = options.maskHaloStyle ?? null;
+    // Halo-only presentations still need prepared id-mask artifacts; this
+    // invisible style drives preparation without drawing any fill or border.
+    const haloOnlyMaskStyle = {
+        artifactKey: "mask-halo-only:v1",
+        resolve: (detection) => detection.mask
+            ? { alpha: 0, color: 0x000000, mask: detection.mask }
+            : undefined,
+    };
+    const createVisibilityMaskHaloStyle = (style) => ({
+        resolve(detection, context) {
+            const state = resolveContextState(detection);
+            if (state.hidden) {
+                return undefined;
+            }
+            return style.resolve(detection, { ...context, ...state });
+        },
+    });
+    const resolveArtifactMaskStyle = () => currentMaskStyle ?? (currentMaskHaloStyle ? haloOnlyMaskStyle : null);
     let currentPolygonStyle = options.polygonStyle === undefined
         ? new BasePolygonStyle()
         : options.polygonStyle;
     let currentVisibility = options.visibility;
+    let currentMediaTime = 0;
+    let viewportScale = 1;
+    let hasPresentedSample = false;
+    let mediaHeight = 0;
+    let mediaWidth = 0;
     let visibilityVersion = 0;
     let visibilityMaskStyleCache = null;
     const resolveContextState = (detection) => resolveAnnotationStyleState(detection, currentVisibility);
@@ -7791,6 +9093,28 @@ async function createPixiMediaScene(options) {
         hidden: currentVisibility?.labelsHidden === true ||
             resolveContextState(detection).hidden,
     });
+    // The vector layer consumes one shape style; renderer kinds that lower to
+    // shape instructions compose with the internal hook here.
+    function resolveVectorShapeStyle() {
+        const kindShapeStyle = resolveAnnotationShapeStyle({
+            boxCornerStyle: currentBoxCornerStyle,
+            ellipseStyle: currentEllipseStyle,
+            markerStyle: currentMarkerStyle,
+        });
+        const baseShapeStyle = options.shapeStyle ?? null;
+        if (!kindShapeStyle || !baseShapeStyle) {
+            return kindShapeStyle ?? baseShapeStyle;
+        }
+        return {
+            resolve(detection, context) {
+                const combined = [
+                    ...(baseShapeStyle.resolve(detection, context) ?? []),
+                    ...(kindShapeStyle.resolve(detection, context) ?? []),
+                ];
+                return combined.length > 0 ? combined : undefined;
+            },
+        };
+    }
     const boxLayer = createPixiBoxLayer({
         boxStyle: options.boxStyle,
         Container: options.editingEngine ? Container : undefined,
@@ -7823,6 +9147,24 @@ async function createPixiMediaScene(options) {
         polygonStyle: polygonLayer?.getVectorFallbackStyle() ?? currentPolygonStyle,
         polylineStyle: options.polylineStyle,
         keypointStyle: options.keypointStyle,
+        shapeStyle: resolveVectorShapeStyle(),
+        resolveContextState,
+    });
+    const regionLayer = createPixiRegionLayer({
+        Assets,
+        Container,
+        GifSprite,
+        Sprite,
+        detectionTimeline: options.detectionTimeline,
+        onInvalidate: () => {
+            if (!hasPresentedSample || mediaWidth <= 0 || mediaHeight <= 0)
+                return;
+            const boxState = boxLayer.drawFrame(currentMediaTime, viewportScale);
+            const regionState = regionLayer.drawFrame(currentMediaTime, viewportScale);
+            options.onPresentationUpdate?.(createPresentedSampleState(currentMediaTime, boxState, regionState));
+        },
+        onAssetError: options.diagnostics?.onAssetError,
+        regionRenderers: options.regionRenderers,
         resolveContextState,
     });
     const annotationOverlayLayer = createPixiAnnotationOverlayLayer(options.editingEngine, options.annotationOverlayStyle);
@@ -7836,9 +9178,11 @@ async function createPixiMediaScene(options) {
             preview: options.maskBrush,
         })
         : undefined;
-    let maskLayer = options.maskStyle
+    let maskLayer = resolveArtifactMaskStyle()
         ? createPixiMaskLayer({
+            BlurFilter,
             Container,
+            Rectangle,
             ImageSource,
             Mesh,
             MeshGeometry,
@@ -7847,7 +9191,10 @@ async function createPixiMediaScene(options) {
             Texture,
             UniformGroup,
             detectionTimeline: options.detectionTimeline,
-            maskStyle: createVisibilityMaskStyle(options.maskStyle),
+            maskHaloStyle: currentMaskHaloStyle
+                ? createVisibilityMaskHaloStyle(currentMaskHaloStyle)
+                : null,
+            maskStyle: createVisibilityMaskStyle(resolveArtifactMaskStyle()),
             onActiveIdMaskFramePresented: handleActiveIdMaskFramePresented,
             renderPreparation: options.renderPreparation,
         })
@@ -7879,8 +9226,6 @@ async function createPixiMediaScene(options) {
     if (!stagingContext) {
         throw new Error("Unable to create staging canvas context.");
     }
-    let mediaHeight = 0;
-    let mediaWidth = 0;
     let mediaScene;
     let vectorDisplay;
     let polygonDisplay;
@@ -7889,6 +9234,7 @@ async function createPixiMediaScene(options) {
     const maskSlot = createPixiSceneLayerSlot(PixiSceneLayerKind.Mask);
     const boxSlot = createPixiSceneLayerSlot(PixiSceneLayerKind.Box);
     const vectorSlot = createPixiSceneLayerSlot(PixiSceneLayerKind.Vector);
+    const regionSlot = createPixiSceneLayerSlot(PixiSceneLayerKind.Region);
     const focusSlot = createPixiSceneLayerSlot(PixiSceneLayerKind.Focus);
     const previewSlot = createPixiSceneLayerSlot(PixiSceneLayerKind.Preview);
     const interactionSlot = createPixiSceneLayerSlot(PixiSceneLayerKind.Interaction);
@@ -7899,16 +9245,14 @@ async function createPixiMediaScene(options) {
         maskSlot,
         boxSlot,
         vectorSlot,
+        regionSlot,
         focusSlot,
         previewSlot,
         handleSlot,
         interactionSlot,
         labelSlot,
     ];
-    let currentMediaTime = 0;
-    let viewportScale = 1;
     const viewport = createViewportController({ scale: 1 });
-    let hasPresentedSample = false;
     /**
      * Timestamp of the sample whose pixels are on the staging canvas. Unlike
      * `currentMediaTime`, presentation and selection updates never move it.
@@ -7924,6 +9268,7 @@ async function createPixiMediaScene(options) {
             interaction: options.interaction ?? {
                 mode: MediaInteractionMode.Always,
             },
+            canPickDetection: (detection) => !resolveAnnotationStyleState(detection, currentVisibility).hidden,
             editingEngine: options.editingEngine,
             capturePointer: (pointerId) => {
                 if (!rendererCanvas.hasPointerCapture?.(pointerId)) {
@@ -7960,6 +9305,7 @@ async function createPixiMediaScene(options) {
             Text,
             UniformGroup,
             interactionStyle: options.interactionStyle,
+            isDetectionVisible: (detection) => !resolveAnnotationStyleState(detection, currentVisibility).hidden,
         })
         : undefined;
     let fastTranslatedDetectionId = null;
@@ -7967,6 +9313,7 @@ async function createPixiMediaScene(options) {
         fastTranslatedDetectionId = id;
         boxLayer.translateDetection(id, dx, dy);
         vectorLayer.translateDetection(id, dx, dy);
+        regionLayer.translateDetection(id, dx, dy);
         labelLayer?.translateDetection(id, dx, dy);
     });
     const unsubscribeEditingState = options.editingEngine?.subscribe((state) => {
@@ -7978,11 +9325,13 @@ async function createPixiMediaScene(options) {
         fastTranslatedDetectionId = null;
         boxLayer.translateDetection(id, 0, 0);
         vectorLayer.translateDetection(id, 0, 0);
+        regionLayer.translateDetection(id, 0, 0);
         labelLayer?.translateDetection(id, 0, 0);
         boxLayer.invalidateDetection(id);
         vectorLayer.invalidateDetection(id);
         boxLayer.drawFrame(currentMediaTime, viewportScale);
         vectorLayer.drawFrame(currentMediaTime, viewportScale);
+        regionLayer.drawFrame(currentMediaTime, viewportScale);
         labelLayer?.drawFrame(currentMediaTime, viewportScale);
     });
     const handleKeyDown = (event) => {
@@ -8017,6 +9366,7 @@ async function createPixiMediaScene(options) {
             Shader,
             UniformGroup,
             focusStyle: options.focusStyle,
+            isDetectionVisible: (detection) => !resolveAnnotationStyleState(detection, currentVisibility).hidden,
         })
         : undefined;
     let mediaSprite;
@@ -8126,6 +9476,7 @@ async function createPixiMediaScene(options) {
             attachPolygonLayerDisplay();
             vectorDisplay.addChild(vectorLayer.createContainer());
             vectorSlot.setDisplay(vectorDisplay);
+            regionSlot.setDisplay(regionLayer.createContainer());
             previewSlot.setDisplay(maskBrushPreview?.display);
             if (annotationOverlay) {
                 annotationOverlayLayer.attachGraphics(annotationOverlay);
@@ -8179,13 +9530,14 @@ async function createPixiMediaScene(options) {
                     const boxState = boxLayer.drawFrame(sample.timestamp, viewportScale);
                     polygonLayer?.drawFrame(sample.timestamp, viewportScale);
                     vectorLayer.drawFrame(sample.timestamp, viewportScale);
+                    const regionState = regionLayer.drawFrame(sample.timestamp, viewportScale);
                     interactionLayer?.drawFrame(sample.timestamp);
                     drawFocusLayer(sample.timestamp);
                     drawInteractionPresentationLayer(sample.timestamp);
                     labelLayer?.drawFrame(sample.timestamp, viewportScale);
                     updateMediaSceneFit();
                     return {
-                        ...createPresentedSampleState(sample.timestamp, boxState),
+                        ...createPresentedSampleState(sample.timestamp, boxState, regionState),
                         duration: sample.duration,
                     };
                 }
@@ -8207,10 +9559,12 @@ async function createPixiMediaScene(options) {
                     maskLayer?.drawFrame(sample.timestamp);
                 });
                 let boxState;
+                let regionState;
                 boxMs = measure(() => {
                     boxState = boxLayer.drawFrame(sample.timestamp, viewportScale);
                     polygonLayer?.drawFrame(sample.timestamp, viewportScale);
                     vectorLayer.drawFrame(sample.timestamp, viewportScale);
+                    regionState = regionLayer.drawFrame(sample.timestamp, viewportScale);
                 });
                 interactionMs = measure(() => {
                     interactionLayer?.drawFrame(sample.timestamp);
@@ -8237,7 +9591,7 @@ async function createPixiMediaScene(options) {
                     totalMs: elapsedSince(totalStart),
                 };
                 return {
-                    ...createPresentedSampleState(sample.timestamp, boxState),
+                    ...createPresentedSampleState(sample.timestamp, boxState, regionState),
                     duration: sample.duration,
                     renderTimings,
                 };
@@ -8386,6 +9740,7 @@ async function createPixiMediaScene(options) {
                     visibilityVersion += 1;
                     maskLayer?.setMaskStyle(createVisibilityMaskStyle(currentMaskStyle));
                 }
+                interactionLayer?.drawFrame(mediaTime);
             }
             boxLayer.setBoxStyle(presentation.boxStyle);
             if (presentation.polygonStyle !== undefined) {
@@ -8406,15 +9761,38 @@ async function createPixiMediaScene(options) {
                 polylineStyle: presentation.polylineStyle,
                 keypointStyle: presentation.keypointStyle,
             });
-            if (presentation.maskStyle !== undefined) {
-                currentMaskStyle = presentation.maskStyle;
-                const nextMaskLayer = presentation.maskStyle
-                    ? ensureMaskLayer(presentation.maskStyle)
+            regionLayer.setRenderers(presentation.renderers?.filter((renderer) => renderer.kind === "region") ?? []);
+            if (presentation.boxCornerStyle !== undefined ||
+                presentation.ellipseStyle !== undefined ||
+                presentation.markerStyle !== undefined) {
+                if (presentation.boxCornerStyle !== undefined) {
+                    currentBoxCornerStyle = presentation.boxCornerStyle;
+                }
+                if (presentation.ellipseStyle !== undefined) {
+                    currentEllipseStyle = presentation.ellipseStyle;
+                }
+                if (presentation.markerStyle !== undefined) {
+                    currentMarkerStyle = presentation.markerStyle;
+                }
+                vectorLayer.setStyles({ shapeStyle: resolveVectorShapeStyle() });
+            }
+            if (presentation.maskStyle !== undefined ||
+                presentation.maskHaloStyle !== undefined) {
+                if (presentation.maskStyle !== undefined) {
+                    currentMaskStyle = presentation.maskStyle;
+                }
+                if (presentation.maskHaloStyle !== undefined) {
+                    currentMaskHaloStyle = presentation.maskHaloStyle;
+                }
+                const artifactStyle = resolveArtifactMaskStyle();
+                const nextMaskLayer = artifactStyle
+                    ? ensureMaskLayer(artifactStyle)
                     : maskLayer;
-                nextMaskLayer?.setMaskStyle(presentation.maskStyle
-                    ? createVisibilityMaskStyle(presentation.maskStyle)
-                    : presentation.maskStyle);
-                if (presentation.maskStyle) {
+                nextMaskLayer?.setMaskStyle(artifactStyle ? createVisibilityMaskStyle(artifactStyle) : null);
+                nextMaskLayer?.setMaskHaloStyle(currentMaskHaloStyle
+                    ? createVisibilityMaskHaloStyle(currentMaskHaloStyle)
+                    : null);
+                if (artifactStyle) {
                     attachMaskLayerDisplay();
                     syncSceneChildren();
                 }
@@ -8448,11 +9826,12 @@ async function createPixiMediaScene(options) {
             const boxState = boxLayer.drawFrame(mediaTime, viewportScale);
             polygonLayer?.drawFrame(mediaTime, viewportScale);
             vectorLayer.drawFrame(mediaTime, viewportScale);
+            const regionState = regionLayer.drawFrame(mediaTime, viewportScale);
             interactionLayer?.drawFrame(mediaTime);
             drawFocusLayer(mediaTime);
             drawInteractionPresentationLayer(mediaTime);
             labelLayer?.drawFrame(mediaTime, viewportScale);
-            return createPresentedSampleState(mediaTime, boxState);
+            return createPresentedSampleState(mediaTime, boxState, regionState);
         },
         setSelectedDetection(selection, mediaTime) {
             currentMediaTime = selection?.mediaTime ?? mediaTime;
@@ -8479,6 +9858,7 @@ async function createPixiMediaScene(options) {
             polygonLayer?.destroy();
             labelLayer?.destroy();
             vectorLayer.destroy();
+            regionLayer.destroy();
             maskBrushPreview?.destroy();
             unsubscribeFastTranslate?.();
             unsubscribeEditingState?.();
@@ -8495,21 +9875,24 @@ async function createPixiMediaScene(options) {
             });
         },
     };
-    function createPresentedSampleState(mediaTime, boxState) {
+    function createPresentedSampleState(mediaTime, boxState, regionState) {
         const detectionFrame = options.detectionTimeline.selectFrame(mediaTime);
         return {
-            activeDetectionCount: countPresentedDetections(detectionFrame, mediaTime, boxState),
+            activeDetectionCount: countPresentedDetections(detectionFrame, mediaTime, boxState, regionState),
             activeDetectionFrameIndex: detectionFrame?.frameIndex ?? null,
             activeDetectionFrameTime: detectionFrame?.mediaTime ?? null,
             detectionBuffer: options.detectionTimeline.getState(),
             mediaTime,
         };
     }
-    function countPresentedDetections(frame, mediaTime, boxState) {
+    function countPresentedDetections(frame, mediaTime, boxState, regionState) {
         if (!frame) {
             return 0;
         }
         const visibleDetectionIndexes = new Set(boxState.activeDetectionIndexes);
+        for (const detectionIndex of regionState?.activeDetectionIndexes ?? []) {
+            visibleDetectionIndexes.add(detectionIndex);
+        }
         for (const [detectionIndex, detection] of frame.detections.entries()) {
             if (visibleDetectionIndexes.has(detectionIndex)) {
                 continue;
@@ -8536,7 +9919,9 @@ async function createPixiMediaScene(options) {
     function ensureMaskLayer(maskStyle) {
         if (!maskLayer) {
             maskLayer = createPixiMaskLayer({
+                BlurFilter,
                 Container,
+                Rectangle,
                 ImageSource,
                 Mesh,
                 MeshGeometry,
@@ -8545,6 +9930,9 @@ async function createPixiMediaScene(options) {
                 Texture,
                 UniformGroup,
                 detectionTimeline: options.detectionTimeline,
+                maskHaloStyle: currentMaskHaloStyle
+                    ? createVisibilityMaskHaloStyle(currentMaskHaloStyle)
+                    : null,
                 maskStyle: createVisibilityMaskStyle(maskStyle),
                 onActiveIdMaskFramePresented: handleActiveIdMaskFramePresented,
                 renderPreparation: options.renderPreparation,
@@ -8622,6 +10010,7 @@ async function createPixiMediaScene(options) {
                 Shader,
                 UniformGroup,
                 focusStyle,
+                isDetectionVisible: (detection) => !resolveAnnotationStyleState(detection, currentVisibility).hidden,
             });
         }
         return focusLayer;
@@ -8657,10 +10046,10 @@ async function createPixiMediaScene(options) {
         const interactionState = interactionLayer?.getState();
         focusLayer.drawFrame({
             frame,
-            hoveredPick: interactionState?.hoveredPick ?? null,
+            hoveredPick: filterVisiblePick(interactionState?.hoveredPick ?? null),
             idMaskArtifact: maskLayer?.getActiveIdMaskFrameTexture() ?? null,
             mediaTime,
-            selectedPick: interactionState?.selectedPick ?? null,
+            selectedPick: filterVisiblePick(interactionState?.selectedPick ?? null),
             viewportScale,
         });
     }
@@ -8672,11 +10061,11 @@ async function createPixiMediaScene(options) {
         const interactionState = interactionLayer?.getState();
         interactionPresentationLayer.drawFrame({
             frame,
-            hoveredPick: interactionState?.hoveredPick ?? null,
+            hoveredPick: filterVisiblePick(interactionState?.hoveredPick ?? null),
             idMaskArtifact: maskLayer?.getActiveIdMaskFrameTexture() ?? null,
             mediaTime,
-            selectedPick: interactionState?.selectedPick ?? null,
-            selectedPicks: interactionState?.selectedPicks,
+            selectedPick: filterVisiblePick(interactionState?.selectedPick ?? null),
+            selectedPicks: interactionState?.selectedPicks.filter(({ detection }) => !resolveAnnotationStyleState(detection, currentVisibility).hidden),
             viewportScale,
         });
     }
@@ -8747,6 +10136,12 @@ async function createPixiMediaScene(options) {
         };
         return visibilityMaskStyle;
     }
+    function filterVisiblePick(pick) {
+        return pick &&
+            !resolveAnnotationStyleState(pick.detection, currentVisibility).hidden
+            ? pick
+            : null;
+    }
 }
 function canReuseMaskVisibilityArtifacts(previous, next) {
     return ((previous?.annotationsHidden === true) ===
@@ -9393,10 +10788,20 @@ async function createMediaSession(options) {
                 ? undefined
                 : { enabledRendererKinds: renderers.map(({ kind }) => kind) });
         };
-        const resolveRendererPresentation = (presentation) => ({
-            ...resolvePresentation(presentation),
-            renderers: undefined,
-        });
+        const resolveRendererPresentation = (presentation) => {
+            const resolved = resolvePresentation(presentation);
+            return {
+                ...resolved,
+                // Style-backed renderers have already been lowered into their
+                // specialized fields, including source overrides. Keep their kinds in
+                // the authoritative list so the renderer core does not clear those
+                // fields when direct renderers are also present, but let the resolved
+                // fields win over the descriptors' original global styles.
+                renderers: resolved.renderers?.map((renderer) => renderer.kind === "region"
+                    ? renderer
+                    : { ...renderer, style: undefined }),
+            };
+        };
         const initialPresentation = resolveRendererPresentation(currentPresentation);
         const renderer = await createMediaRenderer({
             ...options.renderer,
@@ -9404,6 +10809,8 @@ async function createMediaSession(options) {
             backgroundColor: initialPresentation.backgroundColor,
             annotationOverlayStyle: initialPresentation.annotationOverlayStyle,
             boxStyle: initialPresentation.boxStyle,
+            boxCornerStyle: initialPresentation.boxCornerStyle,
+            ellipseStyle: initialPresentation.ellipseStyle,
             container: options.container,
             detectionBuffer: sessionDefaults.detectionBuffer,
             detectionFrames: sessionDetections.detectionFrames,
@@ -9412,9 +10819,12 @@ async function createMediaSession(options) {
             focusStyle: initialPresentation.focusStyle,
             interactionStyle: initialPresentation.interactionStyle,
             labelStyle: initialPresentation.labelStyle,
+            maskHaloStyle: initialPresentation.maskHaloStyle,
             maskStyle: initialPresentation.maskStyle,
+            markerStyle: initialPresentation.markerStyle,
             polygonStyle: initialPresentation.polygonStyle,
             polylineStyle: initialPresentation.polylineStyle,
+            renderers: initialPresentation.renderers,
             keypointStyle: initialPresentation.keypointStyle,
             visibility: initialPresentation.visibility,
             onState(state) {
@@ -9569,5 +10979,5 @@ function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
 
-export { DetectionTimelineOrigin, MediaNormalizationAudioCodec, MediaNormalizationContainer, MediaNormalizationFit, MediaNormalizationVideoCodec, MediaPreparationError, MediaProbeIssueCode, MediaProbeStatus, RenderPreparationArtifactFrameStatus, RenderPreparationArtifactKind, RenderPreparationExecutionMode, RenderPreparationMode, RenderPreparationWorkerStatus, createBrowserColdDetectionFrameStore, createChunkedDetectionFrameSource, createImageUrlMediaSource, createMediaRenderer, createMediaSession, createMediaStreamRendererSource, createStaticImageMediaSource, normalizeMedia, normalizeMediaProgressively, prepareMedia, prepareMediaProgressively, probeMedia };
+export { DetectionPostProcessingMode, DetectionTimelineOrigin, MediaNormalizationAudioCodec, MediaNormalizationContainer, MediaNormalizationFit, MediaNormalizationVideoCodec, MediaPreparationError, MediaProbeIssueCode, MediaProbeStatus, RenderPreparationArtifactFrameStatus, RenderPreparationArtifactKind, RenderPreparationExecutionMode, RenderPreparationMode, RenderPreparationWorkerStatus, createBrowserColdDetectionFrameStore, createChunkedDetectionFrameSource, createDefaultDetectionPostProcessingWorkerFactory, createDetectionPostProcessingPipeline, createImageUrlMediaSource, createMediaRenderer, createMediaSession, createMediaStreamRendererSource, createStaticImageMediaSource, normalizeMedia, normalizeMediaProgressively, prepareMedia, prepareMediaProgressively, probeMedia };
 //# sourceMappingURL=index.js.map