supervision 0.1.4 → 0.1.5

package/node_modules/supervision-js-core/dist/index.js

@@ -140,6 +140,12 @@ function validateDetectionFrames(detectionFrames) {
             if (detection.zIndex !== undefined) {
                 validateNumber(detection.zIndex, `${detectionPath}.zIndex`);
             }
+            if (detection.trackerId !== undefined) {
+                validateNumber(detection.trackerId, `${detectionPath}.trackerId`, {
+                    integer: true,
+                    min: 0,
+                });
+            }
             if (detection.sourceId !== undefined &&
                 typeof detection.sourceId !== "string") {
                 throw new Error(`${detectionPath}.sourceId must be a string.`);
@@ -1657,22 +1663,1387 @@ function isRangeCovered(range, availableRanges) {
         availableRange.endTime + RANGE_EPSILON_SECONDS >= range.endTime);
 }
 
-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 = {}));
+/**
+ * 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 = {}));
+function encodeBinaryMask(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const runs = [];
+    let currentValue = 0;
+    let runLength = 0;
+    for (let x = 0; x < width; x += 1) {
+        for (let y = 0; y < height; y += 1) {
+            const value = data[y * width + x] ? 1 : 0;
+            if (value === currentValue) {
+                runLength += 1;
+            }
+            else {
+                runs.push(runLength);
+                currentValue = value;
+                runLength = 1;
+            }
+        }
+    }
+    runs.push(runLength);
+    return {
+        counts: encodeCompressedRleCounts(runs),
+        encoding: DetectionMaskEncoding.CompressedRle,
+        height,
+        width,
+    };
+}
+/** Encodes a binary mask and derives its bounds in the same raster traversal. */
+function encodeBinaryMaskWithBounds(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const runs = [];
+    let currentValue = 0;
+    let runLength = 0;
+    let minX = width;
+    let minY = height;
+    let maxX = -1;
+    let maxY = -1;
+    for (let x = 0; x < width; x += 1) {
+        for (let y = 0; y < height; y += 1) {
+            const value = data[y * width + x] ? 1 : 0;
+            if (value) {
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+            if (value === currentValue) {
+                runLength += 1;
+            }
+            else {
+                runs.push(runLength);
+                currentValue = value;
+                runLength = 1;
+            }
+        }
+    }
+    runs.push(runLength);
+    return {
+        bounds: maxX < 0
+            ? null
+            : {
+                height: maxY - minY + 1,
+                width: maxX - minX + 1,
+                x: minX + (maxX - minX + 1) / 2,
+                y: minY + (maxY - minY + 1) / 2,
+            },
+        mask: {
+            counts: encodeCompressedRleCounts(runs),
+            encoding: DetectionMaskEncoding.CompressedRle,
+            height,
+            width,
+        },
+    };
+}
+function encodeDetectionMaskPayload(mask, codec) {
+    return codec ? codec.deflate(mask.counts) : mask.counts;
+}
+function decodeDetectionMaskPayload(payload, width, height, options = {}) {
+    const format = options.format ??
+        (isDeflatedBase64DetectionMaskPayload(payload)
+            ? DetectionMaskPayloadFormat.DeflatedBase64
+            : DetectionMaskPayloadFormat.RawCocoRle);
+    if (format === DetectionMaskPayloadFormat.DeflatedBase64 && !options.codec) {
+        throw new Error("A detection mask compression codec is required for deflated payloads.");
+    }
+    return {
+        counts: format === DetectionMaskPayloadFormat.DeflatedBase64
+            ? options.codec.inflate(payload)
+            : payload,
+        encoding: DetectionMaskEncoding.CompressedRle,
+        height,
+        width,
+    };
+}
+/** Matches the annotation editor's legacy transport-format heuristic. */
+function isDeflatedBase64DetectionMaskPayload(value) {
+    return value.length > 100 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}
+function computeMaskBounds(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    let minX = width;
+    let minY = height;
+    let maxX = -1;
+    let maxY = -1;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            if (!data[y * width + x]) {
+                continue;
+            }
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+    }
+    if (maxX < 0) {
+        return null;
+    }
+    const boundsWidth = maxX - minX + 1;
+    const boundsHeight = maxY - minY + 1;
+    return {
+        height: boundsHeight,
+        width: boundsWidth,
+        x: minX + boundsWidth / 2,
+        y: minY + boundsHeight / 2,
+    };
+}
+function computeDetectionMaskRect(mask) {
+    const decoded = decodeCompressedRleMask(mask);
+    const bounds = computeMaskBounds(decoded.data, decoded.width, decoded.height);
+    return bounds ?? undefined;
+}
+function detectMaskBorders(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const borders = new Uint8Array(data.length);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const offset = y * width + x;
+            if (!data[offset]) {
+                continue;
+            }
+            if (x === 0 ||
+                y === 0 ||
+                x === width - 1 ||
+                y === height - 1 ||
+                !data[offset - 1] ||
+                !data[offset + 1] ||
+                !data[offset - width] ||
+                !data[offset + width]) {
+                borders[offset] = 1;
+            }
+        }
+    }
+    return borders;
+}
+function extractMaskContour(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const stride = Math.max(1, Math.floor(height / 100));
+    const leftEdge = [];
+    const rightEdge = [];
+    for (let y = 0; y < height; y += stride) {
+        let left = -1;
+        let right = -1;
+        for (let x = 0; x < width; x += 1) {
+            if (data[y * width + x]) {
+                left = left === -1 ? x : left;
+                right = x;
+            }
+        }
+        if (left !== -1) {
+            leftEdge.push({ x: left, y });
+            rightEdge.push({ x: right, y });
+        }
+    }
+    return leftEdge.length < 2
+        ? undefined
+        : [...leftEdge, ...rightEdge.reverse()];
+}
+function extractMaskRectRuns(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const rects = [];
+    const openRects = new Map();
+    for (let y = 0; y < height; y += 1) {
+        const activeSpans = new Set();
+        let x = 0;
+        while (x < width) {
+            while (x < width && !data[y * width + x]) {
+                x += 1;
+            }
+            if (x >= width) {
+                break;
+            }
+            const startX = x;
+            while (x < width && data[y * width + x]) {
+                x += 1;
+            }
+            const runWidth = x - startX;
+            const key = `${startX}:${runWidth}`;
+            const openRect = openRects.get(key);
+            activeSpans.add(key);
+            if (openRect && openRect.y + openRect.height === y) {
+                openRects.set(key, { ...openRect, height: openRect.height + 1 });
+            }
+            else {
+                if (openRect) {
+                    rects.push(openRect);
+                }
+                openRects.set(key, { height: 1, width: runWidth, x: startX, y });
+            }
+        }
+        for (const [key, openRect] of openRects) {
+            if (!activeSpans.has(key)) {
+                rects.push(openRect);
+                openRects.delete(key);
+            }
+        }
+    }
+    rects.push(...openRects.values());
+    return rects.length > 0 ? rects : undefined;
+}
+function assertMaskDimensions(data, width, height) {
+    if (!Number.isInteger(width) || width <= 0) {
+        throw new Error("Mask width must be a positive integer.");
+    }
+    if (!Number.isInteger(height) || height <= 0) {
+        throw new Error("Mask height must be a positive integer.");
+    }
+    if (data.length !== width * height) {
+        throw new Error("Mask data length must equal width * height.");
+    }
+}
 
 function centerRectToTopLeftRect(rect) {
     return {
@@ -1769,10 +3140,220 @@ function polygonArea(points) {
     }
     return Math.abs(twiceArea) / 2;
 }
-function rectArea(rect) {
-    return rect ? Math.max(0, rect.width) * Math.max(0, rect.height) : 0;
+function rectArea(rect) {
+    return rect ? Math.max(0, rect.width) * Math.max(0, rect.height) : 0;
+}
+
+const DEFAULT_LOST_TRACK_BUFFER = 30;
+const DEFAULT_FRAME_RATE = 30;
+const DEFAULT_TRACK_ACTIVATION_THRESHOLD = 0.25;
+const DEFAULT_MINIMUM_CONSECUTIVE_FRAMES = 3;
+const DEFAULT_MINIMUM_IOU_THRESHOLD = 0.3;
+const DEFAULT_BYTE_TRACK_ACTIVATION_THRESHOLD = 0.7;
+const DEFAULT_BYTE_MINIMUM_CONSECUTIVE_FRAMES = 2;
+const DEFAULT_BYTE_MINIMUM_IOU_THRESHOLD = 0.1;
+const DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD = 0.6;
+const DEFAULT_CBIOU_FIRST_IOU_THRESHOLD = 0.2;
+const DEFAULT_CBIOU_SECOND_IOU_THRESHOLD = 0.5;
+const DEFAULT_CBIOU_UNCONFIRMED_IOU_THRESHOLD = 0.3;
+const DEFAULT_CBIOU_FIRST_BUFFER_RATIO = 0.3;
+const DEFAULT_CBIOU_SECOND_BUFFER_RATIO = 0.5;
+const DEFAULT_OCSORT_DIRECTION_CONSISTENCY_WEIGHT = 0.2;
+const DEFAULT_OCSORT_DELTA_T = 3;
+const detectionPostProcessors = {
+    tracking: ((options = {}) => {
+        const isByteTrack = options.algorithm === "bytetrack";
+        const isCBIoU = options.algorithm === "cbiou";
+        const isOCSort = options.algorithm === "ocsort";
+        const lostTrackBuffer = normalizeNonNegativeInteger(options.lostTrackBuffer, DEFAULT_LOST_TRACK_BUFFER, "lostTrackBuffer");
+        const frameRate = options.frameRate ?? DEFAULT_FRAME_RATE;
+        const trackActivationThreshold = options.trackActivationThreshold ??
+            (isByteTrack || isCBIoU
+                ? DEFAULT_BYTE_TRACK_ACTIVATION_THRESHOLD
+                : DEFAULT_TRACK_ACTIVATION_THRESHOLD);
+        const minimumConsecutiveFrames = normalizePositiveInteger(options.minimumConsecutiveFrames, isByteTrack || isCBIoU
+            ? DEFAULT_BYTE_MINIMUM_CONSECUTIVE_FRAMES
+            : DEFAULT_MINIMUM_CONSECUTIVE_FRAMES, "minimumConsecutiveFrames");
+        const minimumIouThreshold = options.minimumIouThreshold ??
+            (isByteTrack
+                ? DEFAULT_BYTE_MINIMUM_IOU_THRESHOLD
+                : DEFAULT_MINIMUM_IOU_THRESHOLD);
+        if (!Number.isFinite(frameRate) || frameRate <= 0) {
+            throw new Error("frameRate must be a finite positive value.");
+        }
+        normalizeUnitInterval(trackActivationThreshold, "trackActivationThreshold");
+        normalizeUnitInterval(minimumIouThreshold, "minimumIouThreshold");
+        const base = {
+            geometry: options.geometry ?? TrackingGeometry.Box,
+            kind: "tracking",
+        };
+        if (isCBIoU) {
+            const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ??
+                DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD;
+            const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ??
+                DEFAULT_CBIOU_FIRST_IOU_THRESHOLD;
+            const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ??
+                DEFAULT_CBIOU_SECOND_IOU_THRESHOLD;
+            const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ??
+                DEFAULT_CBIOU_UNCONFIRMED_IOU_THRESHOLD;
+            const bufferRatioFirst = options.bufferRatioFirst ?? DEFAULT_CBIOU_FIRST_BUFFER_RATIO;
+            const bufferRatioSecond = options.bufferRatioSecond ?? DEFAULT_CBIOU_SECOND_BUFFER_RATIO;
+            normalizeUnitInterval(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+            normalizeUnitInterval(minimumIouThresholdFirstAssociation, "minimumIouThresholdFirstAssociation");
+            normalizeUnitInterval(minimumIouThresholdSecondAssociation, "minimumIouThresholdSecondAssociation");
+            normalizeUnitInterval(minimumIouThresholdUnconfirmedAssociation, "minimumIouThresholdUnconfirmedAssociation");
+            normalizeNonNegativeFinite(bufferRatioFirst, "bufferRatioFirst");
+            normalizeNonNegativeFinite(bufferRatioSecond, "bufferRatioSecond");
+            return {
+                ...base,
+                algorithm: "cbiou",
+                options: {
+                    bufferRatioFirst,
+                    bufferRatioSecond,
+                    frameRate,
+                    highConfidenceDetectionThreshold,
+                    instantFirstFrameActivation: options.instantFirstFrameActivation ?? true,
+                    lostTrackBuffer,
+                    minimumConsecutiveFrames,
+                    minimumIouThresholdFirstAssociation,
+                    minimumIouThresholdSecondAssociation,
+                    minimumIouThresholdUnconfirmedAssociation,
+                    trackActivationThreshold,
+                },
+            };
+        }
+        if (isOCSort) {
+            const directionConsistencyWeight = options.directionConsistencyWeight ??
+                DEFAULT_OCSORT_DIRECTION_CONSISTENCY_WEIGHT;
+            const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ??
+                DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD;
+            const deltaT = normalizePositiveInteger(options.deltaT, DEFAULT_OCSORT_DELTA_T, "deltaT");
+            normalizeUnitInterval(directionConsistencyWeight, "directionConsistencyWeight");
+            normalizeUnitInterval(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+            return {
+                ...base,
+                algorithm: "ocsort",
+                options: {
+                    deltaT,
+                    directionConsistencyWeight,
+                    frameRate,
+                    highConfidenceDetectionThreshold,
+                    lostTrackBuffer,
+                    minimumConsecutiveFrames,
+                    minimumIouThreshold,
+                },
+            };
+        }
+        if (isByteTrack) {
+            const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ??
+                DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD;
+            normalizeUnitInterval(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+            return {
+                ...base,
+                algorithm: "bytetrack",
+                options: {
+                    frameRate,
+                    highConfidenceDetectionThreshold,
+                    lostTrackBuffer,
+                    minimumConsecutiveFrames,
+                    minimumIouThreshold,
+                    trackActivationThreshold,
+                },
+            };
+        }
+        return {
+            ...base,
+            algorithm: "sort",
+            options: {
+                frameRate,
+                lostTrackBuffer,
+                minimumConsecutiveFrames,
+                minimumIouThreshold,
+                trackActivationThreshold,
+            },
+        };
+    }),
+};
+/**
+ * Creates the lightweight projection sent to a tracker or tracking worker.
+ * Masks and keypoint arrays never cross the worker boundary.
+ */
+function projectDetectionFrameForTracking(frame, geometry) {
+    return frame.detections.flatMap((detection, detectionIndex) => {
+        const rect = resolveTrackingRect(detection, geometry);
+        if (!rect || rect.width <= 0 || rect.height <= 0) {
+            return [];
+        }
+        return [
+            {
+                ...(detection.confidence === undefined
+                    ? {}
+                    : { confidence: detection.confidence }),
+                detectionIndex,
+                rect,
+            },
+        ];
+    });
+}
+function resolveTrackingRect(detection, geometry) {
+    switch (geometry) {
+        case TrackingGeometry.Box:
+            return detection.rect;
+        case TrackingGeometry.Mask:
+            if (!detection.mask) {
+                return undefined;
+            }
+            // Most segmentation producers already supply the exact mask bounds as a
+            // rect. Decode RLE only when that inexpensive projection is absent.
+            return detection.rect ?? computeDetectionMaskRect(detection.mask);
+        case TrackingGeometry.Keypoints:
+            return detection.keypoints
+                ? getPointsRect(detection.keypoints.points)
+                : undefined;
+    }
+}
+function normalizePositiveInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return resolved;
+}
+function normalizeNonNegativeInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved < 0) {
+        throw new Error(`${label} must be a non-negative integer.`);
+    }
+    return resolved;
+}
+function normalizeUnitInterval(value, label) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`${label} must be between 0 and 1.`);
+    }
+}
+function normalizeNonNegativeFinite(value, label) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${label} must be a finite non-negative value.`);
+    }
 }
 
+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 = {}));
+
 const decodedMaskCache = new WeakMap();
 function pickDetectionAtPoint(frame, point, options = {}) {
     if (!frame) {
@@ -4284,242 +5865,6 @@ function normalizeGlobalKeypointStyle(style) {
     return style === undefined ? new BaseKeypointStyle() : style;
 }
 
-var DetectionMaskPayloadFormat;
-(function (DetectionMaskPayloadFormat) {
-    DetectionMaskPayloadFormat["RawCocoRle"] = "rawCocoRle";
-    DetectionMaskPayloadFormat["DeflatedBase64"] = "deflatedBase64";
-})(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));
-function encodeBinaryMask(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const runs = [];
-    let currentValue = 0;
-    let runLength = 0;
-    for (let x = 0; x < width; x += 1) {
-        for (let y = 0; y < height; y += 1) {
-            const value = data[y * width + x] ? 1 : 0;
-            if (value === currentValue) {
-                runLength += 1;
-            }
-            else {
-                runs.push(runLength);
-                currentValue = value;
-                runLength = 1;
-            }
-        }
-    }
-    runs.push(runLength);
-    return {
-        counts: encodeCompressedRleCounts(runs),
-        encoding: DetectionMaskEncoding.CompressedRle,
-        height,
-        width,
-    };
-}
-/** Encodes a binary mask and derives its bounds in the same raster traversal. */
-function encodeBinaryMaskWithBounds(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const runs = [];
-    let currentValue = 0;
-    let runLength = 0;
-    let minX = width;
-    let minY = height;
-    let maxX = -1;
-    let maxY = -1;
-    for (let x = 0; x < width; x += 1) {
-        for (let y = 0; y < height; y += 1) {
-            const value = data[y * width + x] ? 1 : 0;
-            if (value) {
-                minX = Math.min(minX, x);
-                minY = Math.min(minY, y);
-                maxX = Math.max(maxX, x);
-                maxY = Math.max(maxY, y);
-            }
-            if (value === currentValue) {
-                runLength += 1;
-            }
-            else {
-                runs.push(runLength);
-                currentValue = value;
-                runLength = 1;
-            }
-        }
-    }
-    runs.push(runLength);
-    return {
-        bounds: maxX < 0
-            ? null
-            : {
-                height: maxY - minY + 1,
-                width: maxX - minX + 1,
-                x: minX + (maxX - minX + 1) / 2,
-                y: minY + (maxY - minY + 1) / 2,
-            },
-        mask: {
-            counts: encodeCompressedRleCounts(runs),
-            encoding: DetectionMaskEncoding.CompressedRle,
-            height,
-            width,
-        },
-    };
-}
-function encodeDetectionMaskPayload(mask, codec) {
-    return codec ? codec.deflate(mask.counts) : mask.counts;
-}
-function decodeDetectionMaskPayload(payload, width, height, options = {}) {
-    const format = options.format ??
-        (isDeflatedBase64DetectionMaskPayload(payload)
-            ? DetectionMaskPayloadFormat.DeflatedBase64
-            : DetectionMaskPayloadFormat.RawCocoRle);
-    if (format === DetectionMaskPayloadFormat.DeflatedBase64 && !options.codec) {
-        throw new Error("A detection mask compression codec is required for deflated payloads.");
-    }
-    return {
-        counts: format === DetectionMaskPayloadFormat.DeflatedBase64
-            ? options.codec.inflate(payload)
-            : payload,
-        encoding: DetectionMaskEncoding.CompressedRle,
-        height,
-        width,
-    };
-}
-/** Matches the annotation editor's legacy transport-format heuristic. */
-function isDeflatedBase64DetectionMaskPayload(value) {
-    return value.length > 100 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
-}
-function computeMaskBounds(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    let minX = width;
-    let minY = height;
-    let maxX = -1;
-    let maxY = -1;
-    for (let y = 0; y < height; y += 1) {
-        for (let x = 0; x < width; x += 1) {
-            if (!data[y * width + x]) {
-                continue;
-            }
-            minX = Math.min(minX, x);
-            minY = Math.min(minY, y);
-            maxX = Math.max(maxX, x);
-            maxY = Math.max(maxY, y);
-        }
-    }
-    if (maxX < 0) {
-        return null;
-    }
-    const boundsWidth = maxX - minX + 1;
-    const boundsHeight = maxY - minY + 1;
-    return {
-        height: boundsHeight,
-        width: boundsWidth,
-        x: minX + boundsWidth / 2,
-        y: minY + boundsHeight / 2,
-    };
-}
-function computeDetectionMaskRect(mask) {
-    const decoded = decodeCompressedRleMask(mask);
-    const bounds = computeMaskBounds(decoded.data, decoded.width, decoded.height);
-    return bounds ?? undefined;
-}
-function detectMaskBorders(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const borders = new Uint8Array(data.length);
-    for (let y = 0; y < height; y += 1) {
-        for (let x = 0; x < width; x += 1) {
-            const offset = y * width + x;
-            if (!data[offset]) {
-                continue;
-            }
-            if (x === 0 ||
-                y === 0 ||
-                x === width - 1 ||
-                y === height - 1 ||
-                !data[offset - 1] ||
-                !data[offset + 1] ||
-                !data[offset - width] ||
-                !data[offset + width]) {
-                borders[offset] = 1;
-            }
-        }
-    }
-    return borders;
-}
-function extractMaskContour(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const stride = Math.max(1, Math.floor(height / 100));
-    const leftEdge = [];
-    const rightEdge = [];
-    for (let y = 0; y < height; y += stride) {
-        let left = -1;
-        let right = -1;
-        for (let x = 0; x < width; x += 1) {
-            if (data[y * width + x]) {
-                left = left === -1 ? x : left;
-                right = x;
-            }
-        }
-        if (left !== -1) {
-            leftEdge.push({ x: left, y });
-            rightEdge.push({ x: right, y });
-        }
-    }
-    return leftEdge.length < 2
-        ? undefined
-        : [...leftEdge, ...rightEdge.reverse()];
-}
-function extractMaskRectRuns(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const rects = [];
-    const openRects = new Map();
-    for (let y = 0; y < height; y += 1) {
-        const activeSpans = new Set();
-        let x = 0;
-        while (x < width) {
-            while (x < width && !data[y * width + x]) {
-                x += 1;
-            }
-            if (x >= width) {
-                break;
-            }
-            const startX = x;
-            while (x < width && data[y * width + x]) {
-                x += 1;
-            }
-            const runWidth = x - startX;
-            const key = `${startX}:${runWidth}`;
-            const openRect = openRects.get(key);
-            activeSpans.add(key);
-            if (openRect && openRect.y + openRect.height === y) {
-                openRects.set(key, { ...openRect, height: openRect.height + 1 });
-            }
-            else {
-                if (openRect) {
-                    rects.push(openRect);
-                }
-                openRects.set(key, { height: 1, width: runWidth, x: startX, y });
-            }
-        }
-        for (const [key, openRect] of openRects) {
-            if (!activeSpans.has(key)) {
-                rects.push(openRect);
-                openRects.delete(key);
-            }
-        }
-    }
-    rects.push(...openRects.values());
-    return rects.length > 0 ? rects : undefined;
-}
-function assertMaskDimensions(data, width, height) {
-    if (!Number.isInteger(width) || width <= 0) {
-        throw new Error("Mask width must be a positive integer.");
-    }
-    if (!Number.isInteger(height) || height <= 0) {
-        throw new Error("Mask height must be a positive integer.");
-    }
-    if (data.length !== width * height) {
-        throw new Error("Mask data length must equal width * height.");
-    }
-}
-
 function rectToPolygon(rect) {
     const halfWidth = rect.width / 2;
     const halfHeight = rect.height / 2;
@@ -5060,5 +6405,5 @@ var MediaSessionActivityStatus;
     MediaSessionActivityStatus["Waiting"] = "waiting";
 })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));
 
-export { AnnotationFrameMutationKind, AnnotationGeometryKind, AnnotationGestureStateKind, AnnotationHandleKind, BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, StrokeAlignment as BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionMaskPayloadFormat, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MAX_ID_MASK_PALETTE_ENTRIES, MAX_ID_MASK_STROKE_WIDTH, MarkerShape, MarkerSizeSpace, MaskRenderMode, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, RegionRendererComposeMode, RegionRendererRegionKind, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, ShapeInstructionKind, StrokeAlignment, annotationRendererKinds, annotationRenderers, applyAnnotationHandleDrag, canReuseMaskStyleArtifacts, centerRectToTopLeftRect, computeDetectionMaskRect, computeMaskBounds, containsPoint, convertDetectionBoxToMask, convertDetectionBoxToPolygon, convertDetectionMaskToBox, convertDetectionMaskToPolygon, convertDetectionPolygonToBox, convertDetectionPolygonToMask, copySortedDetectionFrames, createAnnotationEditingEngine, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createDetectionPickKey, createEditableAnnotationFrameSession, createIdMaskFrame, createIdleDetectionBufferState, createMemoryColdDetectionFrameStore, createSourceAwarePresentation, createViewportController, createWritableDetectionFrameSource, decodeCompressedRleCounts, decodeCompressedRleMask, decodeDetectionMaskPayload, deleteAnnotationVertex, detectMaskBorders, detectionFrameOverlapsRange, distanceToSegment, encodeBinaryMask, encodeBinaryMaskWithBounds, encodeCompressedRleCounts, encodeDetectionMaskPayload, extractMaskContour, extractMaskRectRuns, filterDetectionFramesForRange, findClosestAnnotationSegment, followDetectionPickAcrossFrames, getAnnotationHandles, getBufferedDetectionTimelineFrameSnapshot, getDetectionRect, getPointsRect, haveSameDetectionPickIdentities, includeDefined, isDeflatedBase64DetectionMaskPayload, lightenColor, mediaToScreen, mergeDetectionMasks, mergeDetectionPolygonsByClass, normalizeDetectionClassName, offsetDetection, pickAnnotationHandle, pickDetectionAtPoint, pickDetectionByMaskId, pointInPolygon, polygonArea, polygonToRect, rasterizePolygonToMask, rasterizeRectToMask, rebaseDetectionPickToFrame, rectArea, rectToPolygon, resolveAnnotationRendererPresentation, resolveAnnotationStyleState, resolveContrastTextColor, resolveDetectionClassColorStyle, resolveEllipseSegmentCount, resolveMarkerGeometry, resolveMaskStyleOpacity, resolveStyleValue, sampleEllipseArc, screenToMedia, selectDetectionFrame, topLeftRectToCenterRect, validateDetectionFrames };
+export { AnnotationFrameMutationKind, AnnotationGeometryKind, AnnotationGestureStateKind, AnnotationHandleKind, BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, StrokeAlignment as BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionMaskPayloadFormat, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MAX_ID_MASK_PALETTE_ENTRIES, MAX_ID_MASK_STROKE_WIDTH, MarkerShape, MarkerSizeSpace, MaskRenderMode, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, RegionRendererComposeMode, RegionRendererRegionKind, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, ShapeInstructionKind, StrokeAlignment, TrackingGeometry, annotationRendererKinds, annotationRenderers, applyAnnotationHandleDrag, canReuseMaskStyleArtifacts, centerRectToTopLeftRect, computeDetectionMaskRect, computeMaskBounds, containsPoint, convertDetectionBoxToMask, convertDetectionBoxToPolygon, convertDetectionMaskToBox, convertDetectionMaskToPolygon, convertDetectionPolygonToBox, convertDetectionPolygonToMask, copySortedDetectionFrames, createAnnotationEditingEngine, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createDetectionPickKey, createEditableAnnotationFrameSession, createIdMaskFrame, createIdleDetectionBufferState, createMemoryColdDetectionFrameStore, createOCSortTracker, createSortTracker, createSourceAwarePresentation, createViewportController, createWritableDetectionFrameSource, decodeCompressedRleCounts, decodeCompressedRleMask, decodeDetectionMaskPayload, deleteAnnotationVertex, detectMaskBorders, detectionFrameOverlapsRange, detectionPostProcessors, distanceToSegment, encodeBinaryMask, encodeBinaryMaskWithBounds, encodeCompressedRleCounts, encodeDetectionMaskPayload, extractMaskContour, extractMaskRectRuns, filterDetectionFramesForRange, findClosestAnnotationSegment, followDetectionPickAcrossFrames, getAnnotationHandles, getBufferedDetectionTimelineFrameSnapshot, getDetectionRect, getPointsRect, haveSameDetectionPickIdentities, includeDefined, isDeflatedBase64DetectionMaskPayload, lightenColor, mediaToScreen, mergeDetectionMasks, mergeDetectionPolygonsByClass, normalizeDetectionClassName, offsetDetection, pickAnnotationHandle, pickDetectionAtPoint, pickDetectionByMaskId, pointInPolygon, polygonArea, polygonToRect, projectDetectionFrameForTracking, rasterizePolygonToMask, rasterizeRectToMask, rebaseDetectionPickToFrame, rectArea, rectToPolygon, resolveAnnotationRendererPresentation, resolveAnnotationStyleState, resolveContrastTextColor, resolveDetectionClassColorStyle, resolveEllipseSegmentCount, resolveMarkerGeometry, resolveMaskStyleOpacity, resolveStyleValue, sampleEllipseArc, screenToMedia, selectDetectionFrame, topLeftRectToCenterRect, validateDetectionFrames };
 //# sourceMappingURL=index.js.map