supervision 0.1.4 → 0.1.6

package/dist/tracking.worker.js

@@ -0,0 +1,1509 @@
+(function () {
+    'use strict';
+
+    /** COCO-compatible keypoint visibility values. */
+    var KeypointVisibility;
+    (function (KeypointVisibility) {
+        KeypointVisibility[KeypointVisibility["NotLabeled"] = 0] = "NotLabeled";
+        KeypointVisibility[KeypointVisibility["Occluded"] = 1] = "Occluded";
+        KeypointVisibility[KeypointVisibility["Visible"] = 2] = "Visible";
+    })(KeypointVisibility || (KeypointVisibility = {}));
+    var DetectionMaskEncoding;
+    (function (DetectionMaskEncoding) {
+        DetectionMaskEncoding["CompressedRle"] = "compressedRle";
+    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));
+
+    var DetectionBufferStatus;
+    (function (DetectionBufferStatus) {
+        DetectionBufferStatus["Idle"] = "idle";
+        DetectionBufferStatus["Loading"] = "loading";
+        DetectionBufferStatus["Ready"] = "ready";
+        DetectionBufferStatus["Error"] = "error";
+        DetectionBufferStatus["Destroyed"] = "destroyed";
+    })(DetectionBufferStatus || (DetectionBufferStatus = {}));
+    /**
+     * How the renderer selects the active detection frame for a media timestamp.
+     */
+    var DetectionFrameSelectionMode;
+    (function (DetectionFrameSelectionMode) {
+        /**
+         * Select the frame whose `[mediaTime, endTime)` interval contains the media
+         * time. This is the default for interval annotations and timestamped sources.
+         */
+        DetectionFrameSelectionMode["Interval"] = "interval";
+        /**
+         * Select from a known inference frame grid using `frameIndex`, `frameRate`,
+         * and optional `frameIndexOriginTime`. This is useful when inference was run
+         * on normalized frames and playback should snap detections to that grid.
+         */
+        DetectionFrameSelectionMode["NearestFrameIndex"] = "nearestFrameIndex";
+    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));
+    var DetectionFrameRetentionMode;
+    (function (DetectionFrameRetentionMode) {
+        /**
+         * Keep writable detections only in an in-memory store. Useful for ephemeral
+         * live streams where old predictions should disappear when evicted.
+         */
+        DetectionFrameRetentionMode["MemoryOnly"] = "memoryOnly";
+        /**
+         * Persist every written detection frame. Useful for finite media where seek
+         * and replay should not require recomputing detections.
+         */
+        DetectionFrameRetentionMode["PersistAll"] = "persistAll";
+        /**
+         * Persist only the most recent retention window. Useful for long-running
+         * streams where replay is bounded to a recent time horizon.
+         */
+        DetectionFrameRetentionMode["PersistWindow"] = "persistWindow";
+    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));
+
+    var AnnotationFrameMutationKind;
+    (function (AnnotationFrameMutationKind) {
+        AnnotationFrameMutationKind["Add"] = "add";
+        AnnotationFrameMutationKind["Remove"] = "remove";
+        AnnotationFrameMutationKind["Replace"] = "replace";
+        AnnotationFrameMutationKind["Transact"] = "transact";
+        AnnotationFrameMutationKind["Update"] = "update";
+    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));
+
+    /**
+     * Creates one stateful SORT tracker for a single ordered media sequence.
+     *
+     * Defaults, lifecycle semantics, and observation-only output mirror
+     * roboflow/trackers SORT. Motion predictions remain internal to association.
+     */
+    function createSortTracker$1(options = {}) {
+        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, "lostTrackBuffer");
+        const frameRate = options.frameRate ?? 30;
+        const trackActivationThreshold = options.trackActivationThreshold ?? 0.25;
+        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, "minimumConsecutiveFrames");
+        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;
+        if (!Number.isFinite(frameRate) || frameRate <= 0) {
+            throw new Error("frameRate must be a finite positive value.");
+        }
+        normalizeUnitInterval$1(trackActivationThreshold, "trackActivationThreshold");
+        normalizeUnitInterval$1(minimumIouThreshold, "minimumIouThreshold");
+        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;
+        if (!Number.isFinite(scaledLostTrackBuffer)) {
+            throw new Error("Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.");
+        }
+        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));
+        let tracks = [];
+        let nextTrackerId = 0;
+        let previousFrameIndex;
+        return {
+            reset() {
+                tracks = [];
+                nextTrackerId = 0;
+                previousFrameIndex = undefined;
+            },
+            update(detections, frameIndex) {
+                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);
+                previousFrameIndex = frameIndex ?? previousFrameIndex;
+                const predicted = tracks.map((track) => track.predict(frameStep, frameRate));
+                const { matches, unmatchedDetections } = associateDetectionsToTracks(detections, predicted, minimumIouThreshold);
+                const trackerIds = new Map();
+                for (const match of matches) {
+                    const track = tracks[match.trackIndex];
+                    const detection = detections[match.detectionIndex];
+                    track.update(detection);
+                    if (track.trackerId === undefined &&
+                        track.successfulUpdates >= minimumConsecutiveFrames) {
+                        track.trackerId = nextTrackerId;
+                        nextTrackerId += 1;
+                    }
+                    if (track.trackerId !== undefined) {
+                        trackerIds.set(detection.detectionIndex, track.trackerId);
+                    }
+                }
+                for (const detectionIndex of unmatchedDetections) {
+                    const detection = detections[detectionIndex];
+                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {
+                        tracks.push(new KalmanBoxTrack(detection));
+                    }
+                }
+                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&
+                    (track.successfulUpdates >= minimumConsecutiveFrames ||
+                        track.timeSinceUpdate === 0));
+                return {
+                    activeTrackCount: tracks.length,
+                    assignments: detections.flatMap((detection) => {
+                        const trackerId = trackerIds.get(detection.detectionIndex);
+                        return trackerId === undefined
+                            ? []
+                            : [{ detectionIndex: detection.detectionIndex, trackerId }];
+                    }),
+                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,
+                };
+            },
+        };
+    }
+    class KalmanBoxTrack {
+        consecutiveUpdates;
+        trackerId;
+        successfulUpdates = 1;
+        timeSinceUpdate = 0;
+        state;
+        covariance = identity(8);
+        constructor(detection, consecutiveUpdates = false) {
+            this.consecutiveUpdates = consecutiveUpdates;
+            this.state = [...rectToXyxy(detection.rect), 0, 0, 0, 0].map((value) => [
+                value,
+            ]);
+        }
+        predict(frameStep, frameRate) {
+            if (this.consecutiveUpdates && this.timeSinceUpdate > 0) {
+                this.successfulUpdates = 0;
+            }
+            const transition = identity(8);
+            for (let index = 0; index < 4; index += 1) {
+                transition[index][index + 4] = frameStep;
+            }
+            this.state = multiply(transition, this.state);
+            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), createProcessNoise(frameStep, frameRate));
+            // Python SORT counts update calls for the fixed-rate lost-track budget.
+            this.timeSinceUpdate += 1;
+            return stateToRect(this.state);
+        }
+        update(detection) {
+            const measurement = rectToXyxy(detection.rect).map((value) => [value]);
+            const observation = [
+                [1, 0, 0, 0, 0, 0, 0, 0],
+                [0, 1, 0, 0, 0, 0, 0, 0],
+                [0, 0, 1, 0, 0, 0, 0, 0],
+                [0, 0, 0, 1, 0, 0, 0, 0],
+            ];
+            const measurementNoise = scale(identity(4), 0.1);
+            const innovation = subtract(measurement, multiply(observation, this.state));
+            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));
+            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), measurementNoise);
+            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));
+            this.state = add(this.state, multiply(gain, innovation));
+            const identityMinusGainObservation = subtract(identity(8), multiply(gain, observation));
+            // Joseph form matches the Python implementation and is more stable.
+            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, measurementNoise), transpose(gain)));
+            this.timeSinceUpdate = 0;
+            this.successfulUpdates += 1;
+        }
+        getStateRect() {
+            return stateToRect(this.state);
+        }
+    }
+    function associateDetectionsToTracks(detections, predicted, minimumIouThreshold) {
+        if (predicted.length === 0 || detections.length === 0) {
+            return {
+                matches: [],
+                unmatchedDetections: detections.map((_, index) => index),
+            };
+        }
+        // Python SORT associates all detections class-agnostically using standard IoU.
+        const scores = predicted.map((rect) => detections.map((detection) => intersectionOverUnion(rect, detection.rect)));
+        const candidateMatches = maximizeAssignment(scores);
+        const matches = [];
+        const matchedDetections = new Set();
+        for (const [trackIndex, detectionIndex] of candidateMatches) {
+            if (scores[trackIndex][detectionIndex] < minimumIouThreshold)
+                continue;
+            matches.push({ detectionIndex, trackIndex });
+            matchedDetections.add(detectionIndex);
+        }
+        matches.sort((left, right) => left.trackIndex - right.trackIndex);
+        return {
+            matches,
+            unmatchedDetections: detections.flatMap((_, index) => matchedDetections.has(index) ? [] : [index]),
+        };
+    }
+    /** Hungarian assignment for a rectangular score matrix. */
+    function maximizeAssignment(scores) {
+        if (scores.length === 0 || scores[0]?.length === 0) {
+            return [];
+        }
+        const rowCount = scores.length;
+        const columnCount = scores[0].length;
+        const transposed = rowCount > columnCount;
+        const costs = transposed
+            ? Array.from({ length: columnCount }, (_, row) => Array.from({ length: rowCount }, (_, column) => 1 - scores[column][row]))
+            : scores.map((row) => row.map((score) => 1 - score));
+        const rows = costs.length;
+        const columns = costs[0].length;
+        const u = new Array(rows + 1).fill(0);
+        const v = new Array(columns + 1).fill(0);
+        const p = new Array(columns + 1).fill(0);
+        const way = new Array(columns + 1).fill(0);
+        for (let row = 1; row <= rows; row += 1) {
+            p[0] = row;
+            let column0 = 0;
+            const minValue = new Array(columns + 1).fill(Number.POSITIVE_INFINITY);
+            const used = new Array(columns + 1).fill(false);
+            do {
+                used[column0] = true;
+                const row0 = p[column0];
+                let delta = Number.POSITIVE_INFINITY;
+                let column1 = 0;
+                for (let column = 1; column <= columns; column += 1) {
+                    if (used[column])
+                        continue;
+                    const current = costs[row0 - 1][column - 1] - u[row0] - v[column];
+                    if (current < minValue[column]) {
+                        minValue[column] = current;
+                        way[column] = column0;
+                    }
+                    if (minValue[column] < delta) {
+                        delta = minValue[column];
+                        column1 = column;
+                    }
+                }
+                for (let column = 0; column <= columns; column += 1) {
+                    if (used[column]) {
+                        u[p[column]] += delta;
+                        v[column] -= delta;
+                    }
+                    else {
+                        minValue[column] -= delta;
+                    }
+                }
+                column0 = column1;
+            } while (p[column0] !== 0);
+            do {
+                const column1 = way[column0];
+                p[column0] = p[column1];
+                column0 = column1;
+            } while (column0 !== 0);
+        }
+        const assignments = [];
+        for (let column = 1; column <= columns; column += 1) {
+            if (p[column] === 0)
+                continue;
+            const row = p[column] - 1;
+            assignments.push(transposed ? [column - 1, row] : [row, column - 1]);
+        }
+        return assignments;
+    }
+    function rectToXyxy(rect) {
+        return [
+            rect.x - rect.width / 2,
+            rect.y - rect.height / 2,
+            rect.x + rect.width / 2,
+            rect.y + rect.height / 2,
+        ];
+    }
+    function stateToRect(state) {
+        // The Python XYXY estimator intentionally leaves corner velocities
+        // unconstrained. Normalize only at the browser Rect boundary so a crossing
+        // prediction cannot violate the positive-width/height storage contract.
+        const x1 = Math.min(state[0][0], state[2][0]);
+        const y1 = Math.min(state[1][0], state[3][0]);
+        const x2 = Math.max(state[0][0], state[2][0]);
+        const y2 = Math.max(state[1][0], state[3][0]);
+        return {
+            height: Math.max(Number.EPSILON, y2 - y1),
+            width: Math.max(Number.EPSILON, x2 - x1),
+            x: (x1 + x2) / 2,
+            y: (y1 + y2) / 2,
+        };
+    }
+    function createProcessNoise(frameStep, frameRate) {
+        if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {
+            return scale(identity(8), 0.01);
+        }
+        const result = Array.from({ length: 8 }, () => new Array(8).fill(0));
+        const dt2 = frameStep * frameStep;
+        const dt3 = dt2 * frameStep;
+        const dt4 = dt2 * dt2;
+        for (let index = 0; index < 4; index += 1) {
+            const velocityIndex = index + 4;
+            result[index][index] = (0.01 * dt4) / 4;
+            result[index][velocityIndex] = (0.01 * dt3) / 2;
+            result[velocityIndex][index] = (0.01 * dt3) / 2;
+            result[velocityIndex][velocityIndex] = 0.01 * dt2;
+        }
+        return result;
+    }
+    function intersectionOverUnion(left, right) {
+        const leftX = left.x - left.width / 2;
+        const leftY = left.y - left.height / 2;
+        const rightX = right.x - right.width / 2;
+        const rightY = right.y - right.height / 2;
+        const intersectionWidth = Math.max(0, Math.min(leftX + left.width, rightX + right.width) -
+            Math.max(leftX, rightX));
+        const intersectionHeight = Math.max(0, Math.min(leftY + left.height, rightY + right.height) -
+            Math.max(leftY, rightY));
+        const intersection = intersectionWidth * intersectionHeight;
+        const union = left.width * left.height + right.width * right.height - intersection;
+        return union <= 0 ? 0 : intersection / union;
+    }
+    function resolveFrameStep(current, previous) {
+        if (current === undefined || previous === undefined)
+            return 1;
+        return Math.max(1, current - previous);
+    }
+    function normalizePositiveInteger$1(value, label) {
+        if (!Number.isInteger(value) || value < 1) {
+            throw new Error(`${label} must be a positive integer.`);
+        }
+        return value;
+    }
+    function normalizeNonNegativeInteger$1(value, label) {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`${label} must be a non-negative integer.`);
+        }
+        return value;
+    }
+    function normalizeUnitInterval$1(value, label) {
+        if (!Number.isFinite(value) || value < 0 || value > 1) {
+            throw new Error(`${label} must be between 0 and 1.`);
+        }
+    }
+    function identity(size) {
+        return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));
+    }
+    function scale(matrix, factor) {
+        return matrix.map((row) => row.map((value) => value * factor));
+    }
+    function transpose(matrix) {
+        return matrix[0].map((_, column) => matrix.map((row) => row[column]));
+    }
+    function add(left, right) {
+        return left.map((row, rowIndex) => row.map((value, columnIndex) => value + right[rowIndex][columnIndex]));
+    }
+    function subtract(left, right) {
+        return left.map((row, rowIndex) => row.map((value, columnIndex) => value - right[rowIndex][columnIndex]));
+    }
+    function multiply(left, right) {
+        return left.map((row) => right[0].map((_, column) => row.reduce((sum, value, index) => sum + value * right[index][column], 0)));
+    }
+    function inverse(matrix) {
+        const size = matrix.length;
+        const augmented = matrix.map((row, index) => [
+            ...row,
+            ...identity(size)[index],
+        ]);
+        for (let column = 0; column < size; column += 1) {
+            let pivot = column;
+            for (let row = column + 1; row < size; row += 1) {
+                if (Math.abs(augmented[row][column]) >
+                    Math.abs(augmented[pivot][column])) {
+                    pivot = row;
+                }
+            }
+            if (Math.abs(augmented[pivot][column]) < 1e-12) {
+                throw new Error("SORT Kalman covariance is singular.");
+            }
+            [augmented[column], augmented[pivot]] = [
+                augmented[pivot],
+                augmented[column],
+            ];
+            const divisor = augmented[column][column];
+            augmented[column] = augmented[column].map((value) => value / divisor);
+            for (let row = 0; row < size; row += 1) {
+                if (row === column)
+                    continue;
+                const factor = augmented[row][column];
+                augmented[row] = augmented[row].map((value, index) => value - factor * augmented[column][index]);
+            }
+        }
+        return augmented.map((row) => row.slice(size));
+    }
+
+    /**
+     * Creates one stateful ByteTrack tracker for a single ordered media sequence.
+     *
+     * Defaults and two-stage association mirror roboflow/trackers ByteTrack at
+     * source commit 60b21c8a48676784085fbee455559f16b75a7c9a.
+     * Motion predictions remain internal; only observed detections receive IDs.
+     */
+    function createByteTrackTracker$1(options = {}) {
+        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, "lostTrackBuffer");
+        const frameRate = options.frameRate ?? 30;
+        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;
+        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, "minimumConsecutiveFrames");
+        const minimumIouThreshold = options.minimumIouThreshold ?? 0.1;
+        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;
+        if (!Number.isFinite(frameRate) || frameRate <= 0) {
+            throw new Error("frameRate must be a finite positive value.");
+        }
+        normalizeUnitInterval$1(trackActivationThreshold, "trackActivationThreshold");
+        normalizeUnitInterval$1(minimumIouThreshold, "minimumIouThreshold");
+        normalizeUnitInterval$1(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;
+        if (!Number.isFinite(scaledLostTrackBuffer)) {
+            throw new Error("Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.");
+        }
+        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));
+        let tracks = [];
+        let nextTrackerId = 0;
+        let previousFrameIndex;
+        return {
+            reset() {
+                tracks = [];
+                nextTrackerId = 0;
+                previousFrameIndex = undefined;
+            },
+            update(detections, frameIndex) {
+                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);
+                previousFrameIndex = frameIndex ?? previousFrameIndex;
+                tracks.forEach((track) => track.predict(frameStep, frameRate));
+                const highDetectionIndexes = [];
+                const lowDetectionIndexes = [];
+                detections.forEach((detection, index) => {
+                    if ((detection.confidence ?? 1) >= highConfidenceDetectionThreshold) {
+                        highDetectionIndexes.push(index);
+                    }
+                    else {
+                        lowDetectionIndexes.push(index);
+                    }
+                });
+                const assignments = new Map();
+                const firstStage = associate(tracks, detections, highDetectionIndexes, minimumIouThreshold);
+                for (const match of firstStage.matches) {
+                    updateMatchedTrack(tracks[match.trackIndex], detections[match.detectionIndex], assignments);
+                }
+                const remainingTracks = firstStage.unmatchedTrackIndexes.map((index) => tracks[index]);
+                const secondStage = associate(remainingTracks, detections, lowDetectionIndexes, minimumIouThreshold);
+                for (const match of secondStage.matches) {
+                    updateMatchedTrack(remainingTracks[match.trackIndex], detections[match.detectionIndex], assignments);
+                }
+                // Only unmatched high-confidence observations can start a track.
+                for (const detectionIndex of firstStage.unmatchedDetectionIndexes) {
+                    const detection = detections[detectionIndex];
+                    if ((detection.confidence ?? 1) >= trackActivationThreshold) {
+                        tracks.push(new KalmanBoxTrack(detection, true));
+                    }
+                }
+                // Confirmation is sticky once an ID has been allocated. An unmatched
+                // unconfirmed track is discarded immediately, as in Python ByteTrack.
+                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&
+                    (track.trackerId !== undefined ||
+                        track.successfulUpdates >= minimumConsecutiveFrames ||
+                        track.timeSinceUpdate === 0));
+                return {
+                    activeTrackCount: tracks.length,
+                    assignments: detections.flatMap((detection) => {
+                        const trackerId = assignments.get(detection.detectionIndex);
+                        return trackerId === undefined
+                            ? []
+                            : [{ detectionIndex: detection.detectionIndex, trackerId }];
+                    }),
+                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,
+                };
+            },
+        };
+        function updateMatchedTrack(track, detection, assignments) {
+            track.update(detection);
+            if (track.trackerId === undefined &&
+                track.successfulUpdates >= minimumConsecutiveFrames) {
+                track.trackerId = nextTrackerId;
+                nextTrackerId += 1;
+            }
+            if (track.trackerId !== undefined) {
+                assignments.set(detection.detectionIndex, track.trackerId);
+            }
+        }
+    }
+    function associate(tracks, detections, detectionIndexes, minimumIouThreshold) {
+        if (tracks.length === 0 || detectionIndexes.length === 0) {
+            return {
+                matches: [],
+                unmatchedDetectionIndexes: [...detectionIndexes],
+                unmatchedTrackIndexes: tracks.map((_, index) => index),
+            };
+        }
+        const scores = tracks.map((track) => {
+            const predictedRect = track.getStateRect();
+            return detectionIndexes.map((detectionIndex) => intersectionOverUnion(predictedRect, detections[detectionIndex].rect));
+        });
+        const matches = [];
+        const matchedTracks = new Set();
+        const matchedDetections = new Set();
+        for (const [trackIndex, localDetectionIndex] of maximizeAssignment(scores)) {
+            if (scores[trackIndex][localDetectionIndex] < minimumIouThreshold) {
+                continue;
+            }
+            const detectionIndex = detectionIndexes[localDetectionIndex];
+            matches.push({ detectionIndex, trackIndex });
+            matchedTracks.add(trackIndex);
+            matchedDetections.add(detectionIndex);
+        }
+        matches.sort((left, right) => left.trackIndex - right.trackIndex);
+        return {
+            matches,
+            unmatchedDetectionIndexes: detectionIndexes.filter((index) => !matchedDetections.has(index)),
+            unmatchedTrackIndexes: tracks.flatMap((_, index) => matchedTracks.has(index) ? [] : [index]),
+        };
+    }
+
+    function associateTrackingScores(scores, trackCount, detectionCount, minimumScore, acceptanceScores = scores) {
+        const matches = [];
+        const matchedTracks = new Set();
+        const matchedDetections = new Set();
+        for (const [trackIndex, detectionIndex] of maximizeAssignment(scores)) {
+            if (acceptanceScores[trackIndex][detectionIndex] < minimumScore)
+                continue;
+            matches.push({ detectionIndex, trackIndex });
+            matchedTracks.add(trackIndex);
+            matchedDetections.add(detectionIndex);
+        }
+        matches.sort((left, right) => left.trackIndex - right.trackIndex);
+        return {
+            matches,
+            unmatchedDetectionIndexes: Array.from({ length: detectionCount }, (_, index) => index).filter((index) => !matchedDetections.has(index)),
+            unmatchedTrackIndexes: Array.from({ length: trackCount }, (_, index) => index).filter((index) => !matchedTracks.has(index)),
+        };
+    }
+    function pairwiseIou(tracks, detections, bufferRatio = 0) {
+        return tracks.map((track) => detections.map((detection) => bufferedIntersectionOverUnion(track, detection, bufferRatio)));
+    }
+    function bufferedIntersectionOverUnion(left, right, bufferRatio) {
+        const leftWidth = left.width * (1 + 2 * bufferRatio);
+        const leftHeight = left.height * (1 + 2 * bufferRatio);
+        const rightWidth = right.width * (1 + 2 * bufferRatio);
+        const rightHeight = right.height * (1 + 2 * bufferRatio);
+        const leftX = left.x - leftWidth / 2;
+        const leftY = left.y - leftHeight / 2;
+        const rightX = right.x - rightWidth / 2;
+        const rightY = right.y - rightHeight / 2;
+        const intersectionWidth = Math.max(0, Math.min(leftX + leftWidth, rightX + rightWidth) - Math.max(leftX, rightX));
+        const intersectionHeight = Math.max(0, Math.min(leftY + leftHeight, rightY + rightHeight) -
+            Math.max(leftY, rightY));
+        const intersection = intersectionWidth * intersectionHeight;
+        const union = leftWidth * leftHeight + rightWidth * rightHeight - intersection;
+        return union <= 0 ? 0 : intersection / union;
+    }
+
+    /**
+     * Kalman state estimator shared by the browser C-BIoU and OC-SORT ports.
+     * Its layouts, covariance update, and gap-scaled constant-velocity model
+     * mirror roboflow/trackers at 60b21c8.
+     */
+    class TrackingKalmanEstimator {
+        representation;
+        dimension;
+        measurementDimension = 4;
+        covariance;
+        measurementNoise = identity(4);
+        processNoise;
+        state;
+        baselineProcessNoise;
+        positionIndexes;
+        velocityIndexes;
+        constructor(initialRect, representation) {
+            this.representation = representation;
+            const measurement = rectToMeasurement(initialRect, representation);
+            this.dimension = representation === "xcycsr" ? 7 : 8;
+            this.positionIndexes =
+                representation === "xcycsr" ? [0, 1, 2] : [0, 1, 2, 3];
+            this.velocityIndexes =
+                representation === "xcycsr" ? [4, 5, 6] : [4, 5, 6, 7];
+            this.state = Array.from({ length: this.dimension }, (_, index) => [
+                measurement[index] ?? 0,
+            ]);
+            this.covariance = identity(this.dimension);
+            this.processNoise = identity(this.dimension);
+            this.baselineProcessNoise = identity(this.dimension);
+        }
+        predict(frameStep, frameRate) {
+            if (this.representation === "xcycsr" &&
+                this.state[2][0] + frameStep * this.state[6][0] <= 0) {
+                this.state[6][0] = 0;
+            }
+            const transition = identity(this.dimension);
+            this.positionIndexes.forEach((positionIndex, index) => {
+                transition[positionIndex][this.velocityIndexes[index]] = frameStep;
+            });
+            this.processNoise = this.createProcessNoise(frameStep, frameRate);
+            this.state = multiply(transition, this.state);
+            this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), this.processNoise);
+        }
+        update(rect) {
+            this.updateMeasurement(rectToMeasurement(rect, this.representation));
+        }
+        updateMeasurement(measurement) {
+            const observation = Array.from({ length: 4 }, (_, row) => Array.from({ length: this.dimension }, (_, column) => row === column ? 1 : 0));
+            const measurementColumn = measurement.map((value) => [value]);
+            const innovation = subtract(measurementColumn, multiply(observation, this.state));
+            const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));
+            const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), this.measurementNoise);
+            const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));
+            this.state = add(this.state, multiply(gain, innovation));
+            const identityMinusGainObservation = subtract(identity(this.dimension), multiply(gain, observation));
+            this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, this.measurementNoise), transpose(gain)));
+        }
+        getRect() {
+            return measurementToRect(this.state.slice(0, 4).map((row) => row[0]), this.representation);
+        }
+        setCovariances(options) {
+            if (options.covariance)
+                this.covariance = clone(options.covariance);
+            if (options.measurementNoise) {
+                this.measurementNoise = clone(options.measurementNoise);
+            }
+            if (options.processNoise) {
+                this.processNoise = clone(options.processNoise);
+                this.baselineProcessNoise = clone(options.processNoise);
+            }
+        }
+        snapshot() {
+            return {
+                covariance: clone(this.covariance),
+                measurementNoise: clone(this.measurementNoise),
+                processNoise: clone(this.processNoise),
+                state: clone(this.state),
+            };
+        }
+        restore(snapshot) {
+            this.covariance = clone(snapshot.covariance);
+            this.measurementNoise = clone(snapshot.measurementNoise);
+            this.processNoise = clone(snapshot.processNoise);
+            this.state = clone(snapshot.state);
+        }
+        createProcessNoise(frameStep, frameRate) {
+            if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {
+                return clone(this.baselineProcessNoise);
+            }
+            const result = Array.from({ length: this.dimension }, () => new Array(this.dimension).fill(0));
+            const dt2 = frameStep * frameStep;
+            const dt3 = dt2 * frameStep;
+            const dt4 = dt2 * dt2;
+            const kinematicIndexes = new Set([
+                ...this.positionIndexes,
+                ...this.velocityIndexes,
+            ]);
+            this.positionIndexes.forEach((positionIndex, index) => {
+                const velocityIndex = this.velocityIndexes[index];
+                const accelerationVariance = this.baselineProcessNoise[velocityIndex][velocityIndex];
+                result[positionIndex][positionIndex] = (accelerationVariance * dt4) / 4;
+                result[positionIndex][velocityIndex] = (accelerationVariance * dt3) / 2;
+                result[velocityIndex][positionIndex] = (accelerationVariance * dt3) / 2;
+                result[velocityIndex][velocityIndex] = accelerationVariance * dt2;
+            });
+            for (let index = 0; index < this.dimension; index += 1) {
+                if (!kinematicIndexes.has(index)) {
+                    result[index][index] = this.baselineProcessNoise[index][index];
+                }
+            }
+            return result;
+        }
+    }
+    function rectToMeasurement(rect, representation) {
+        if (representation === "xcycwh") {
+            return [rect.x, rect.y, rect.width, rect.height];
+        }
+        return [
+            rect.x,
+            rect.y,
+            rect.width * rect.height,
+            rect.width / (rect.height + 1e-6),
+        ];
+    }
+    function measurementToRect(measurement, representation) {
+        const [x, y, third, fourth] = measurement;
+        if (representation === "xcycwh") {
+            return {
+                height: Math.max(1e-3, fourth),
+                width: Math.max(1e-3, third),
+                x,
+                y,
+            };
+        }
+        const width = Math.sqrt(third * fourth);
+        const height = width === 0 ? 0 : third / width;
+        return {
+            height: Math.max(Number.EPSILON, height),
+            width: Math.max(Number.EPSILON, width),
+            x,
+            y,
+        };
+    }
+    function diagonal(values) {
+        return values.map((value, row) => values.map((_, column) => (row === column ? value : 0)));
+    }
+    function scaleMatrix(matrix, factor) {
+        return scale(matrix, factor);
+    }
+    function clone(matrix) {
+        return matrix.map((row) => [...row]);
+    }
+
+    const MINIMUM_DETECTION_CONFIDENCE = 0.1;
+    class CBIoUTrack {
+        trackerId;
+        successfulUpdates = 1;
+        timeSinceUpdate = 0;
+        estimator;
+        constructor(initial) {
+            this.estimator = new TrackingKalmanEstimator(initial.rect, "xcycwh");
+            this.setInitialNoise(initial.rect.width, initial.rect.height);
+        }
+        predict(frameStep, frameRate) {
+            const current = this.estimator.getRect();
+            this.estimator.setCovariances({
+                processNoise: this.buildProcessNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),
+            });
+            this.estimator.predict(frameStep, frameRate);
+            this.clampState();
+            this.timeSinceUpdate += 1;
+        }
+        update(detection) {
+            const current = this.estimator.getRect();
+            this.estimator.setCovariances({
+                measurementNoise: this.buildMeasurementNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),
+            });
+            this.estimator.update(detection.rect);
+            this.clampState();
+            this.timeSinceUpdate = 0;
+            this.successfulUpdates += 1;
+        }
+        getRect() {
+            return this.estimator.getRect();
+        }
+        setInitialNoise(width, height) {
+            const sigmaPosition = 0.05;
+            const sigmaVelocity = 0.00625;
+            this.estimator.setCovariances({
+                covariance: diagonal([
+                    (2 * sigmaPosition * width) ** 2,
+                    (2 * sigmaPosition * height) ** 2,
+                    (2 * sigmaPosition * width) ** 2,
+                    (2 * sigmaPosition * height) ** 2,
+                    (10 * sigmaVelocity * width) ** 2,
+                    (10 * sigmaVelocity * height) ** 2,
+                    (10 * sigmaVelocity * width) ** 2,
+                    (10 * sigmaVelocity * height) ** 2,
+                ]),
+                measurementNoise: this.buildMeasurementNoise(width, height),
+                processNoise: this.buildProcessNoise(width, height),
+            });
+        }
+        buildProcessNoise(width, height) {
+            const sigmaPosition = 0.05;
+            const sigmaVelocity = 0.00625;
+            return diagonal([
+                (sigmaPosition * width) ** 2,
+                (sigmaPosition * height) ** 2,
+                (sigmaPosition * width) ** 2,
+                (sigmaPosition * height) ** 2,
+                (sigmaVelocity * width) ** 2,
+                (sigmaVelocity * height) ** 2,
+                (sigmaVelocity * width) ** 2,
+                (sigmaVelocity * height) ** 2,
+            ]);
+        }
+        buildMeasurementNoise(width, height) {
+            const sigmaMeasurement = 0.05;
+            return diagonal([
+                (sigmaMeasurement * width) ** 2,
+                (sigmaMeasurement * height) ** 2,
+                (sigmaMeasurement * width) ** 2,
+                (sigmaMeasurement * height) ** 2,
+            ]);
+        }
+        clampState() {
+            this.estimator.state[2][0] = Math.max(this.estimator.state[2][0], 1e-3);
+            this.estimator.state[3][0] = Math.max(this.estimator.state[3][0], 1e-3);
+        }
+    }
+    /** Creates the detection-only C-BIoU implementation from roboflow/trackers. */
+    function createCBIoUTracker$1(options = {}) {
+        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, "lostTrackBuffer");
+        const frameRate = options.frameRate ?? 30;
+        const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;
+        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, "minimumConsecutiveFrames");
+        const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ?? 0.2;
+        const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ?? 0.5;
+        const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ?? 0.3;
+        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;
+        const instantFirstFrameActivation = options.instantFirstFrameActivation ?? true;
+        const bufferRatioFirst = options.bufferRatioFirst ?? 0.3;
+        const bufferRatioSecond = options.bufferRatioSecond ?? 0.5;
+        if (!Number.isFinite(frameRate) || frameRate <= 0) {
+            throw new Error("frameRate must be a finite positive value.");
+        }
+        normalizeUnitInterval$1(trackActivationThreshold, "trackActivationThreshold");
+        normalizeUnitInterval$1(minimumIouThresholdFirstAssociation, "minimumIouThresholdFirstAssociation");
+        normalizeUnitInterval$1(minimumIouThresholdSecondAssociation, "minimumIouThresholdSecondAssociation");
+        normalizeUnitInterval$1(minimumIouThresholdUnconfirmedAssociation, "minimumIouThresholdUnconfirmedAssociation");
+        normalizeUnitInterval$1(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+        if (!Number.isFinite(bufferRatioFirst) || bufferRatioFirst < 0) {
+            throw new Error("bufferRatioFirst must be a finite non-negative value.");
+        }
+        if (!Number.isFinite(bufferRatioSecond) || bufferRatioSecond < 0) {
+            throw new Error("bufferRatioSecond must be a finite non-negative value.");
+        }
+        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;
+        if (!Number.isFinite(scaledLostTrackBuffer)) {
+            throw new Error("Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.");
+        }
+        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));
+        let tracks = [];
+        let nextTrackerId = 0;
+        let frameId = 0;
+        let previousFrameIndex;
+        return {
+            reset() {
+                tracks = [];
+                nextTrackerId = 0;
+                frameId = 0;
+                previousFrameIndex = undefined;
+            },
+            update(detections, frameIndex) {
+                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);
+                previousFrameIndex = frameIndex ?? previousFrameIndex;
+                frameId += 1;
+                tracks.forEach((track) => track.predict(frameStep, frameRate));
+                const highDetectionIndexes = [];
+                const lowDetectionIndexes = [];
+                detections.forEach((detection, index) => {
+                    const confidence = detection.confidence ?? 1;
+                    if (confidence >= highConfidenceDetectionThreshold) {
+                        highDetectionIndexes.push(index);
+                    }
+                    else if (confidence > MINIMUM_DETECTION_CONFIDENCE) {
+                        lowDetectionIndexes.push(index);
+                    }
+                });
+                const confirmed = [];
+                const unconfirmed = [];
+                const lost = [];
+                for (const track of tracks) {
+                    if (track.timeSinceUpdate > 1)
+                        lost.push(track);
+                    else if (track.trackerId !== undefined ||
+                        track.successfulUpdates >= minimumConsecutiveFrames) {
+                        confirmed.push(track);
+                    }
+                    else
+                        unconfirmed.push(track);
+                }
+                const assignments = new Map();
+                const pool = [...confirmed, ...lost];
+                const highDetections = highDetectionIndexes.map((index) => detections[index]);
+                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)));
+                const firstAssociation = associateTrackingScores(firstScores, pool.length, highDetections.length, minimumIouThresholdFirstAssociation);
+                for (const match of firstAssociation.matches) {
+                    updateMatchedTrack(pool[match.trackIndex], highDetections[match.detectionIndex], assignments);
+                }
+                const remainingTracked = firstAssociation.unmatchedTrackIndexes
+                    .map((index) => pool[index])
+                    .filter((track) => track.timeSinceUpdate === 1);
+                const lowDetections = lowDetectionIndexes.map((index) => detections[index]);
+                const secondScores = pairwiseIou(remainingTracked.map((track) => track.getRect()), lowDetections.map((detection) => detection.rect), bufferRatioSecond);
+                const secondAssociation = associateTrackingScores(secondScores, remainingTracked.length, lowDetections.length, minimumIouThresholdSecondAssociation);
+                for (const match of secondAssociation.matches) {
+                    updateMatchedTrack(remainingTracked[match.trackIndex], lowDetections[match.detectionIndex], assignments);
+                }
+                let unmatchedHighLocal = [...firstAssociation.unmatchedDetectionIndexes];
+                let unmatchedUnconfirmed = unconfirmed.map((_, index) => index);
+                if (unconfirmed.length > 0 && unmatchedHighLocal.length > 0) {
+                    const remainingHigh = unmatchedHighLocal.map((index) => highDetections[index]);
+                    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)));
+                    const unconfirmedAssociation = associateTrackingScores(unconfirmedScores, unconfirmed.length, remainingHigh.length, minimumIouThresholdUnconfirmedAssociation);
+                    unmatchedUnconfirmed = unconfirmedAssociation.unmatchedTrackIndexes;
+                    for (const match of unconfirmedAssociation.matches) {
+                        updateMatchedTrack(unconfirmed[match.trackIndex], remainingHigh[match.detectionIndex], assignments);
+                    }
+                    unmatchedHighLocal =
+                        unconfirmedAssociation.unmatchedDetectionIndexes.map((index) => unmatchedHighLocal[index]);
+                }
+                const unmatchedUnconfirmedTracks = new Set(unmatchedUnconfirmed.map((index) => unconfirmed[index]));
+                tracks = tracks.filter((track) => !unmatchedUnconfirmedTracks.has(track));
+                for (const localIndex of unmatchedHighLocal) {
+                    const detection = highDetections[localIndex];
+                    if ((detection.confidence ?? 1) < trackActivationThreshold)
+                        continue;
+                    const track = new CBIoUTrack(detection);
+                    if (frameId === 1 && instantFirstFrameActivation) {
+                        track.trackerId = nextTrackerId++;
+                        assignments.set(detection.detectionIndex, track.trackerId);
+                    }
+                    tracks.push(track);
+                }
+                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&
+                    (track.timeSinceUpdate === 0 ||
+                        track.trackerId !== undefined ||
+                        track.successfulUpdates >= minimumConsecutiveFrames));
+                return createUpdate(detections, assignments, tracks);
+            },
+        };
+        function updateMatchedTrack(track, detection, assignments) {
+            track.update(detection);
+            if (track.trackerId === undefined &&
+                track.successfulUpdates >= minimumConsecutiveFrames) {
+                track.trackerId = nextTrackerId++;
+            }
+            if (track.trackerId !== undefined) {
+                assignments.set(detection.detectionIndex, track.trackerId);
+            }
+        }
+    }
+    function createUpdate(detections, assignments, tracks) {
+        const resolvedAssignments = detections.flatMap((detection) => {
+            const trackerId = assignments.get(detection.detectionIndex);
+            return trackerId === undefined
+                ? []
+                : [{ detectionIndex: detection.detectionIndex, trackerId }];
+        });
+        return {
+            activeTrackCount: tracks.length,
+            assignments: resolvedAssignments,
+            confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined)
+                .length,
+        };
+    }
+
+    class OCSortTrack {
+        deltaT;
+        age = 0;
+        lastObservation;
+        trackerId;
+        successfulConsecutiveUpdates = 0;
+        timeSinceUpdate = 0;
+        velocity;
+        frozenState;
+        observed = true;
+        observations = new Map();
+        estimator;
+        constructor(initial, deltaT) {
+            this.deltaT = deltaT;
+            this.lastObservation = initial;
+            this.estimator = new TrackingKalmanEstimator(initial.rect, "xcycsr");
+            this.configureNoise();
+        }
+        predict(frameStep, frameRate) {
+            if (this.observed && this.timeSinceUpdate > 0) {
+                this.frozenState = this.estimator.snapshot();
+                this.observed = false;
+            }
+            this.estimator.predict(frameStep, frameRate);
+            if (this.timeSinceUpdate > 0) {
+                this.successfulConsecutiveUpdates = 0;
+            }
+            this.timeSinceUpdate += 1;
+            this.age += 1;
+        }
+        update(detection, frameStep, frameRate) {
+            const previous = this.getPreviousObservation();
+            if (previous) {
+                this.velocity = computeVelocity(previous, detection);
+            }
+            if (!this.observed && this.frozenState) {
+                this.unfreeze(detection, frameStep, frameRate);
+            }
+            this.estimator.update(detection.rect);
+            this.observed = true;
+            this.timeSinceUpdate = 0;
+            this.successfulConsecutiveUpdates += 1;
+            this.lastObservation = detection;
+            this.observations.set(this.age, detection);
+            const cutoff = this.age - this.deltaT;
+            for (const age of this.observations.keys()) {
+                if (age < cutoff)
+                    this.observations.delete(age);
+            }
+        }
+        getRect() {
+            return this.estimator.getRect();
+        }
+        getPreviousObservation() {
+            if (this.observations.size === 0)
+                return undefined;
+            for (let index = 0; index < this.deltaT; index += 1) {
+                const delta = this.deltaT - index;
+                const observation = this.observations.get(this.age - delta);
+                if (observation)
+                    return observation;
+            }
+            const latestAge = Math.max(...this.observations.keys());
+            return this.observations.get(latestAge);
+        }
+        configureNoise() {
+            const measurementNoise = identity(4);
+            for (let index = 2; index < 4; index += 1) {
+                measurementNoise[index][index] *= 10;
+            }
+            const covariance = scaleMatrix(identity(7), 10);
+            for (let index = 4; index < 7; index += 1) {
+                covariance[index][index] *= 1000;
+            }
+            const processNoise = identity(7);
+            processNoise[6][6] *= 0.01;
+            for (let index = 4; index < 7; index += 1) {
+                processNoise[index][index] *= 0.01;
+            }
+            this.estimator.setCovariances({
+                covariance,
+                measurementNoise,
+                processNoise,
+            });
+        }
+        unfreeze(detection, frameStep, frameRate) {
+            if (!this.frozenState || this.timeSinceUpdate === 0)
+                return;
+            this.estimator.restore(this.frozenState);
+            const timeGap = this.timeSinceUpdate;
+            const start = rectToMeasurement(this.lastObservation.rect, "xcycsr");
+            const end = rectToMeasurement(detection.rect, "xcycsr");
+            const startWidth = Math.sqrt(start[2] * start[3]);
+            const startHeight = start[3] === 0 ? 0 : Math.sqrt(start[2] / start[3]);
+            const endWidth = Math.sqrt(end[2] * end[3]);
+            const endHeight = end[3] === 0 ? 0 : Math.sqrt(end[2] / end[3]);
+            for (let index = 0; index < timeGap; index += 1) {
+                const progress = (index + 1) / timeGap;
+                const x = start[0] + progress * (end[0] - start[0]);
+                const y = start[1] + progress * (end[1] - start[1]);
+                const width = startWidth + progress * (endWidth - startWidth);
+                const height = startHeight + progress * (endHeight - startHeight);
+                this.estimator.updateMeasurement([x, y, width * height, width / height]);
+                if (index < timeGap - 1) {
+                    this.estimator.predict(frameStep, frameRate);
+                }
+            }
+            this.frozenState = undefined;
+        }
+    }
+    /** Creates the observation-centric SORT implementation from roboflow/trackers. */
+    function createOCSortTracker$1(options = {}) {
+        const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, "lostTrackBuffer");
+        const frameRate = options.frameRate ?? 30;
+        const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, "minimumConsecutiveFrames");
+        const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;
+        const directionConsistencyWeight = options.directionConsistencyWeight ?? 0.2;
+        const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;
+        const deltaT = normalizePositiveInteger$1(options.deltaT ?? 3, "deltaT");
+        if (!Number.isFinite(frameRate) || frameRate <= 0) {
+            throw new Error("frameRate must be a finite positive value.");
+        }
+        normalizeUnitInterval$1(minimumIouThreshold, "minimumIouThreshold");
+        normalizeUnitInterval$1(directionConsistencyWeight, "directionConsistencyWeight");
+        normalizeUnitInterval$1(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+        const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;
+        if (!Number.isFinite(scaledLostTrackBuffer)) {
+            throw new Error("Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.");
+        }
+        const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));
+        let tracks = [];
+        let frameCount = 0;
+        let nextTrackerId = 0;
+        let previousFrameIndex;
+        return {
+            reset() {
+                tracks = [];
+                frameCount = 0;
+                nextTrackerId = 0;
+                previousFrameIndex = undefined;
+            },
+            update(detections, frameIndex) {
+                const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);
+                previousFrameIndex = frameIndex ?? previousFrameIndex;
+                // Match roboflow/trackers: an empty stream before any track exists is
+                // not part of OC-SORT's early-sequence activation window.
+                if (tracks.length === 0 && detections.length === 0) {
+                    return {
+                        activeTrackCount: 0,
+                        assignments: [],
+                        confirmedTrackCount: 0,
+                    };
+                }
+                tracks.forEach((track) => track.predict(frameStep, frameRate));
+                const highDetectionIndexes = detections.flatMap((detection, index) => detection.confidence === undefined ||
+                    detection.confidence >= highConfidenceDetectionThreshold
+                    ? [index]
+                    : []);
+                const highDetections = highDetectionIndexes.map((index) => detections[index]);
+                const iouScores = pairwiseIou(tracks.map((track) => track.getRect()), highDetections.map((detection) => detection.rect));
+                const combinedScores = iouScores.map((row, trackIndex) => row.map((iou, detectionIndex) => {
+                    if (directionConsistencyWeight === 0)
+                        return iou;
+                    return (iou +
+                        directionConsistencyWeight *
+                            directionConsistency(tracks[trackIndex], highDetections[detectionIndex]) *
+                            (highDetections[detectionIndex].confidence ?? 1));
+                }));
+                const primary = associateTrackingScores(combinedScores, tracks.length, highDetections.length, minimumIouThreshold, iouScores);
+                const assignments = new Map();
+                for (const match of primary.matches) {
+                    updateMatchedTrack(tracks[match.trackIndex], highDetections[match.detectionIndex], assignments, frameStep);
+                }
+                let remainingHigh = [...primary.unmatchedDetectionIndexes];
+                if (primary.unmatchedTrackIndexes.length > 0 &&
+                    remainingHigh.length > 0) {
+                    const unmatchedTracks = primary.unmatchedTrackIndexes.map((index) => tracks[index]);
+                    const unmatchedDetections = remainingHigh.map((index) => highDetections[index]);
+                    const recoveryScores = pairwiseIou(unmatchedTracks.map((track) => track.lastObservation.rect), unmatchedDetections.map((detection) => detection.rect));
+                    const recovery = associateTrackingScores(recoveryScores, unmatchedTracks.length, unmatchedDetections.length, minimumIouThreshold);
+                    for (const match of recovery.matches) {
+                        updateMatchedTrack(unmatchedTracks[match.trackIndex], unmatchedDetections[match.detectionIndex], assignments, frameStep);
+                    }
+                    remainingHigh = recovery.unmatchedDetectionIndexes.map((index) => remainingHigh[index]);
+                }
+                for (const localIndex of remainingHigh) {
+                    tracks.push(new OCSortTrack(highDetections[localIndex], deltaT));
+                }
+                tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate);
+                frameCount += 1;
+                const resolvedAssignments = detections.flatMap((detection) => {
+                    const trackerId = assignments.get(detection.detectionIndex);
+                    return trackerId === undefined
+                        ? []
+                        : [{ detectionIndex: detection.detectionIndex, trackerId }];
+                });
+                return {
+                    activeTrackCount: tracks.length,
+                    assignments: resolvedAssignments,
+                    confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,
+                };
+            },
+        };
+        function updateMatchedTrack(track, detection, assignments, frameStep) {
+            track.update(detection, frameStep, frameRate);
+            const earlySequence = frameCount <= minimumConsecutiveFrames;
+            const shouldEmit = (earlySequence && track.timeSinceUpdate === 0) ||
+                track.successfulConsecutiveUpdates >= minimumConsecutiveFrames;
+            if (shouldEmit) {
+                if (track.trackerId === undefined) {
+                    track.trackerId = nextTrackerId++;
+                }
+                assignments.set(detection.detectionIndex, track.trackerId);
+            }
+        }
+    }
+    function computeVelocity(previous, current) {
+        const deltaX = current.rect.x - previous.rect.x;
+        const deltaY = current.rect.y - previous.rect.y;
+        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;
+        return { x: deltaX / norm, y: deltaY / norm };
+    }
+    function directionConsistency(track, detection) {
+        if (!track.velocity)
+            return 0;
+        const reference = track.getPreviousObservation() ?? track.lastObservation;
+        const deltaX = detection.rect.x - reference.rect.x;
+        const deltaY = detection.rect.y - reference.rect.y;
+        const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;
+        const cosine = Math.max(-1, Math.min(1, track.velocity.x * (deltaX / norm) + track.velocity.y * (deltaY / norm)));
+        const angle = Math.acos(cosine);
+        return (Math.PI / 2 - Math.abs(angle)) / Math.PI;
+    }
+
+    /** Public core facade for the internal tracker engine workspace. */
+    function createSortTracker(options = {}) {
+        return createSortTracker$1(options);
+    }
+
+    /** Public core facade for the internal tracker engine workspace. */
+    function createByteTrackTracker(options = {}) {
+        return createByteTrackTracker$1(options);
+    }
+
+    /** Public core facade for the internal tracker engine workspace. */
+    function createCBIoUTracker(options = {}) {
+        return createCBIoUTracker$1(options);
+    }
+
+    /** Public core facade for the internal tracker engine workspace. */
+    function createOCSortTracker(options = {}) {
+        return createOCSortTracker$1(options);
+    }
+
+    /** Geometry projected into a tracker. The original detection payload is retained. */
+    var TrackingGeometry;
+    (function (TrackingGeometry) {
+        TrackingGeometry["Box"] = "box";
+        TrackingGeometry["Mask"] = "mask";
+        TrackingGeometry["Keypoints"] = "keypoints";
+    })(TrackingGeometry || (TrackingGeometry = {}));
+
+    var DetectionMaskPayloadFormat;
+    (function (DetectionMaskPayloadFormat) {
+        DetectionMaskPayloadFormat["RawCocoRle"] = "rawCocoRle";
+        DetectionMaskPayloadFormat["DeflatedBase64"] = "deflatedBase64";
+    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));
+
+    var DetectionPickTarget;
+    (function (DetectionPickTarget) {
+        DetectionPickTarget["Box"] = "box";
+        DetectionPickTarget["Edge"] = "edge";
+        DetectionPickTarget["Keypoint"] = "keypoint";
+        DetectionPickTarget["Label"] = "label";
+        DetectionPickTarget["Mask"] = "mask";
+        DetectionPickTarget["Polygon"] = "polygon";
+        DetectionPickTarget["Polyline"] = "polyline";
+    })(DetectionPickTarget || (DetectionPickTarget = {}));
+    var MediaInteractionMode;
+    (function (MediaInteractionMode) {
+        MediaInteractionMode["Always"] = "always";
+        MediaInteractionMode["Disabled"] = "disabled";
+        MediaInteractionMode["PausedOnly"] = "pausedOnly";
+    })(MediaInteractionMode || (MediaInteractionMode = {}));
+
+    var AnnotationGeometryKind;
+    (function (AnnotationGeometryKind) {
+        AnnotationGeometryKind["Box"] = "box";
+        AnnotationGeometryKind["Polygon"] = "polygon";
+        AnnotationGeometryKind["Polyline"] = "polyline";
+        AnnotationGeometryKind["Keypoints"] = "keypoints";
+        AnnotationGeometryKind["Mask"] = "mask";
+    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));
+    var AnnotationGestureStateKind;
+    (function (AnnotationGestureStateKind) {
+        AnnotationGestureStateKind["Idle"] = "idle";
+        AnnotationGestureStateKind["Creating"] = "creating";
+        AnnotationGestureStateKind["Moving"] = "moving";
+        AnnotationGestureStateKind["Resizing"] = "resizing";
+        AnnotationGestureStateKind["DragSelecting"] = "dragSelecting";
+    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));
+    var AnnotationHandleKind;
+    (function (AnnotationHandleKind) {
+        AnnotationHandleKind["Resize"] = "resize";
+        AnnotationHandleKind["Vertex"] = "vertex";
+        AnnotationHandleKind["AddVertex"] = "addVertex";
+        AnnotationHandleKind["Keypoint"] = "keypoint";
+    })(AnnotationHandleKind || (AnnotationHandleKind = {}));
+
+    /** Alignment for strokes applied to closed rendered geometry. */
+    var StrokeAlignment;
+    (function (StrokeAlignment) {
+        StrokeAlignment["Inside"] = "inside";
+        StrokeAlignment["Center"] = "center";
+        StrokeAlignment["Outside"] = "outside";
+    })(StrokeAlignment || (StrokeAlignment = {}));
+
+    var BoxShape;
+    (function (BoxShape) {
+        BoxShape["Rect"] = "rect";
+        BoxShape["RoundedRect"] = "roundedRect";
+    })(BoxShape || (BoxShape = {}));
+
+    var FocusTargetMode;
+    (function (FocusTargetMode) {
+        FocusTargetMode["Hovered"] = "hovered";
+        FocusTargetMode["Selected"] = "selected";
+        FocusTargetMode["HoveredAndSelected"] = "hoveredAndSelected";
+        FocusTargetMode["Ambient"] = "ambient";
+    })(FocusTargetMode || (FocusTargetMode = {}));
+
+    var DetectionInteractionState;
+    (function (DetectionInteractionState) {
+        DetectionInteractionState["Hovered"] = "hovered";
+        DetectionInteractionState["Selected"] = "selected";
+    })(DetectionInteractionState || (DetectionInteractionState = {}));
+
+    var LabelPlacement;
+    (function (LabelPlacement) {
+        LabelPlacement["Top"] = "top";
+        LabelPlacement["Bottom"] = "bottom";
+        LabelPlacement["InsideTop"] = "insideTop";
+        LabelPlacement["InsideBottom"] = "insideBottom";
+        LabelPlacement["Center"] = "center";
+    })(LabelPlacement || (LabelPlacement = {}));
+    var LabelVisibilityMode;
+    (function (LabelVisibilityMode) {
+        LabelVisibilityMode["Always"] = "always";
+        LabelVisibilityMode["HoveredOnly"] = "hoveredOnly";
+    })(LabelVisibilityMode || (LabelVisibilityMode = {}));
+
+    var MaskRenderMode;
+    (function (MaskRenderMode) {
+        MaskRenderMode["FillAndStroke"] = "fillAndStroke";
+        MaskRenderMode["FillOnly"] = "fillOnly";
+        MaskRenderMode["StrokeOnly"] = "strokeOnly";
+    })(MaskRenderMode || (MaskRenderMode = {}));
+
+    /**
+     * Discriminator for renderer-neutral shape draw instructions.
+     */
+    var ShapeInstructionKind;
+    (function (ShapeInstructionKind) {
+        ShapeInstructionKind["Ellipse"] = "ellipse";
+        ShapeInstructionKind["Marker"] = "marker";
+        ShapeInstructionKind["Path"] = "path";
+    })(ShapeInstructionKind || (ShapeInstructionKind = {}));
+    var MarkerShape;
+    (function (MarkerShape) {
+        MarkerShape["Circle"] = "circle";
+        MarkerShape["Cross"] = "cross";
+        MarkerShape["Square"] = "square";
+        MarkerShape["Triangle"] = "triangle";
+    })(MarkerShape || (MarkerShape = {}));
+    /**
+     * Coordinate space for marker sizing. Media sizes scale with the viewport;
+     * screen sizes stay constant on screen, matching stroke-width semantics.
+     */
+    var MarkerSizeSpace;
+    (function (MarkerSizeSpace) {
+        MarkerSizeSpace["Media"] = "media";
+        MarkerSizeSpace["Screen"] = "screen";
+    })(MarkerSizeSpace || (MarkerSizeSpace = {}));
+
+    var KeypointMarkerShape;
+    (function (KeypointMarkerShape) {
+        KeypointMarkerShape["Circle"] = "circle";
+        KeypointMarkerShape["Cross"] = "cross";
+    })(KeypointMarkerShape || (KeypointMarkerShape = {}));
+
+    var MediaRendererFit;
+    (function (MediaRendererFit) {
+        /**
+         * Preserve media aspect ratio and fit the full frame inside the canvas.
+         */
+        MediaRendererFit["Contain"] = "contain";
+        /**
+         * Preserve media aspect ratio and fill the canvas, cropping if necessary.
+         */
+        MediaRendererFit["Cover"] = "cover";
+    })(MediaRendererFit || (MediaRendererFit = {}));
+    /**
+     * Playback lifecycle state reported by a platform renderer.
+     */
+    var MediaRendererPlaybackState;
+    (function (MediaRendererPlaybackState) {
+        MediaRendererPlaybackState["Loading"] = "loading";
+        MediaRendererPlaybackState["Ready"] = "ready";
+        MediaRendererPlaybackState["Playing"] = "playing";
+        MediaRendererPlaybackState["Buffering"] = "buffering";
+        MediaRendererPlaybackState["Paused"] = "paused";
+        MediaRendererPlaybackState["Error"] = "error";
+        MediaRendererPlaybackState["Destroyed"] = "destroyed";
+    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));
+    /**
+     * Stable classification of a media failure.
+     *
+     * Applications branch on these kinds instead of parsing decoder, demuxer, or
+     * container error text, and still own their localized user-facing copy. New
+     * kinds may be added over time, so treat unrecognized values like `Unknown`.
+     */
+    var MediaErrorKind;
+    (function (MediaErrorKind) {
+        /** The media could not be opened or read at all. */
+        MediaErrorKind["Unreadable"] = "unreadable";
+        /** The container or codec is not supported by this platform. */
+        MediaErrorKind["UnsupportedFormat"] = "unsupportedFormat";
+        /** The media opened but carries no usable video track. */
+        MediaErrorKind["NoVideoTrack"] = "noVideoTrack";
+        /** Decoding a sample failed after the source opened. */
+        MediaErrorKind["Decode"] = "decode";
+        /** The media could not be fetched. */
+        MediaErrorKind["Network"] = "network";
+        /** The host environment lacks the APIs this media source requires. */
+        MediaErrorKind["EnvironmentUnsupported"] = "environmentUnsupported";
+        /** The failure could not be classified. */
+        MediaErrorKind["Unknown"] = "unknown";
+    })(MediaErrorKind || (MediaErrorKind = {}));
+    /**
+     * Lower-level media source readiness.
+     */
+    var MediaSourceStatus;
+    (function (MediaSourceStatus) {
+        MediaSourceStatus["Loading"] = "loading";
+        MediaSourceStatus["Ready"] = "ready";
+        MediaSourceStatus["Error"] = "error";
+        MediaSourceStatus["Destroyed"] = "destroyed";
+    })(MediaSourceStatus || (MediaSourceStatus = {}));
+
+    /**
+     * Media-session operating mode.
+     *
+     * Core owns the names because file-like and stream-like lifecycle choices are
+     * platform-neutral. Platform packages decide how these modes tune media,
+     * storage, and renderer defaults.
+     */
+    var MediaSessionMode;
+    (function (MediaSessionMode) {
+        /**
+         * Finite media. Defaults usually favor seek/replay and persistent detection
+         * storage.
+         */
+        MediaSessionMode["File"] = "file";
+        /**
+         * Live or append-only media. Defaults usually favor rolling windows and
+         * bounded retention.
+         */
+        MediaSessionMode["Stream"] = "stream";
+    })(MediaSessionMode || (MediaSessionMode = {}));
+    /**
+     * Aggregate lifecycle state for a media session.
+     */
+    var MediaSessionStatus;
+    (function (MediaSessionStatus) {
+        MediaSessionStatus["Buffering"] = "buffering";
+        MediaSessionStatus["Destroyed"] = "destroyed";
+        MediaSessionStatus["Error"] = "error";
+        MediaSessionStatus["Loading"] = "loading";
+        MediaSessionStatus["Paused"] = "paused";
+        MediaSessionStatus["Playing"] = "playing";
+        MediaSessionStatus["Processing"] = "processing";
+        MediaSessionStatus["Ready"] = "ready";
+    })(MediaSessionStatus || (MediaSessionStatus = {}));
+    /**
+     * Subsystem currently affecting session readiness or presentation.
+     */
+    var MediaSessionActivityKind;
+    (function (MediaSessionActivityKind) {
+        MediaSessionActivityKind["DetectionsBuffering"] = "detectionsBuffering";
+        MediaSessionActivityKind["DetectionsLoading"] = "detectionsLoading";
+        MediaSessionActivityKind["Error"] = "error";
+        MediaSessionActivityKind["MediaNormalizing"] = "mediaNormalizing";
+        MediaSessionActivityKind["MediaOpening"] = "mediaOpening";
+        MediaSessionActivityKind["PlaybackBuffering"] = "playbackBuffering";
+        MediaSessionActivityKind["RenderPreparing"] = "renderPreparing";
+    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));
+    /**
+     * State of one session activity.
+     */
+    var MediaSessionActivityStatus;
+    (function (MediaSessionActivityStatus) {
+        MediaSessionActivityStatus["Error"] = "error";
+        MediaSessionActivityStatus["Running"] = "running";
+        MediaSessionActivityStatus["Waiting"] = "waiting";
+    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));
+
+    let tracker;
+    self.addEventListener("message", (event) => {
+        const request = event.data;
+        try {
+            let response;
+            if (request.type === "configure") {
+                switch (request.processor.algorithm) {
+                    case "bytetrack":
+                        tracker = createByteTrackTracker(request.processor.options);
+                        break;
+                    case "cbiou":
+                        tracker = createCBIoUTracker(request.processor.options);
+                        break;
+                    case "ocsort":
+                        tracker = createOCSortTracker(request.processor.options);
+                        break;
+                    default:
+                        tracker = createSortTracker(request.processor.options);
+                }
+                response = { requestId: request.requestId, type: "success" };
+            }
+            else if (request.type === "reset") {
+                tracker?.reset();
+                response = { requestId: request.requestId, type: "success" };
+            }
+            else {
+                if (!tracker) {
+                    throw new Error("Tracking worker is not configured.");
+                }
+                const startedAt = performance.now();
+                const update = tracker.update(request.detections, request.frameIndex);
+                response = {
+                    ...update,
+                    durationMs: performance.now() - startedAt,
+                    requestId: request.requestId,
+                    type: "success",
+                };
+            }
+            self.postMessage(response);
+        }
+        catch (error) {
+            self.postMessage({
+                message: error instanceof Error ? error.message : "Tracking worker failed.",
+                requestId: request.requestId,
+                type: "error",
+            });
+        }
+    });
+
+})();
+//# sourceMappingURL=tracking.worker.js.map