supervision 0.1.3 → 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,221 +1663,1796 @@ 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 = {}));
-
-function centerRectToTopLeftRect(rect) {
+/**
+ * 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 {
-        height: rect.height,
-        width: rect.width,
-        x: rect.x - rect.width / 2,
-        y: rect.y - rect.height / 2,
+        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,
+            };
+        },
     };
 }
-function topLeftRectToCenterRect(rect) {
+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 {
-        height: rect.height,
-        width: rect.width,
-        x: rect.x + rect.width / 2,
-        y: rect.y + rect.height / 2,
+        matches,
+        unmatchedDetections: detections.flatMap((_, index) => matchedDetections.has(index) ? [] : [index]),
     };
 }
-function getPointsRect(points) {
-    if (points.length === 0) {
-        return undefined;
+/** Hungarian assignment for a rectangular score matrix. */
+function maximizeAssignment(scores) {
+    if (scores.length === 0 || scores[0]?.length === 0) {
+        return [];
     }
-    let minX = Number.POSITIVE_INFINITY;
-    let minY = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let maxY = Number.NEGATIVE_INFINITY;
-    for (const point of points) {
-        minX = Math.min(minX, point.x);
-        minY = Math.min(minY, point.y);
-        maxX = Math.max(maxX, point.x);
-        maxY = Math.max(maxY, point.y);
+    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: maxY - minY,
-        width: maxX - minX,
-        x: (minX + maxX) / 2,
-        y: (minY + maxY) / 2,
+        height: Math.max(Number.EPSILON, y2 - y1),
+        width: Math.max(Number.EPSILON, x2 - x1),
+        x: (x1 + x2) / 2,
+        y: (y1 + y2) / 2,
     };
 }
-function getDetectionRect(detection) {
-    return (detection.rect ??
-        getPointsRect(detection.polygon?.points ?? []) ??
-        getPointsRect(detection.polyline?.points ?? []) ??
-        getPointsRect(detection.keypoints?.points ?? []));
+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 containsPoint(rect, point, padding = 0) {
-    const halfWidth = rect.width / 2;
-    const halfHeight = rect.height / 2;
-    return (point.x >= rect.x - halfWidth - padding &&
-        point.x <= rect.x + halfWidth + padding &&
-        point.y >= rect.y - halfHeight - padding &&
-        point.y <= rect.y + halfHeight + padding);
+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 pointInPolygon(point, polygon) {
-    if (polygon.length < 3) {
-        return false;
-    }
-    let inside = false;
-    for (let currentIndex = 0, previousIndex = polygon.length - 1; currentIndex < polygon.length; previousIndex = currentIndex, currentIndex += 1) {
-        const current = polygon[currentIndex];
-        const previous = polygon[previousIndex];
-        const crossesRay = current.y > point.y !== previous.y > point.y &&
-            point.x <
-                ((previous.x - current.x) * (point.y - current.y)) /
-                    (previous.y - current.y) +
-                    current.x;
-        if (crossesRay) {
-            inside = !inside;
-        }
+function normalizePositiveInteger$1(value, label) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive integer.`);
     }
-    return inside;
+    return value;
 }
-function distanceToSegment(point, start, end) {
-    const deltaX = end.x - start.x;
-    const deltaY = end.y - start.y;
-    const lengthSquared = deltaX * deltaX + deltaY * deltaY;
-    if (lengthSquared === 0) {
-        return Math.hypot(point.x - start.x, point.y - start.y);
+function normalizeNonNegativeInteger$1(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer.`);
     }
-    const projection = Math.max(0, Math.min(1, ((point.x - start.x) * deltaX + (point.y - start.y) * deltaY) /
-        lengthSquared));
-    const closestX = start.x + projection * deltaX;
-    const closestY = start.y + projection * deltaY;
-    return Math.hypot(point.x - closestX, point.y - closestY);
+    return value;
 }
-function polygonArea(points) {
-    if (points.length < 3) {
-        return 0;
+function normalizeUnitInterval$1(value, label) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`${label} must be between 0 and 1.`);
     }
-    let twiceArea = 0;
-    for (let index = 0; index < points.length; index += 1) {
-        const current = points[index];
-        const next = points[(index + 1) % points.length];
-        twiceArea += current.x * next.y - next.x * current.y;
-    }
-    return Math.abs(twiceArea) / 2;
 }
-function rectArea(rect) {
-    return rect ? Math.max(0, rect.width) * Math.max(0, rect.height) : 0;
+function identity(size) {
+    return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));
 }
-
-const decodedMaskCache = new WeakMap();
-function pickDetectionAtPoint(frame, point, options = {}) {
-    if (!frame) {
-        return null;
-    }
-    const padding = Math.max(0, options.padding ?? 0);
-    const polylinePadding = Math.max(0, options.polylinePadding ?? 6);
-    const keypointPadding = Math.max(0, options.keypointPadding ?? 10);
-    const edgePadding = Math.max(0, options.edgePadding ?? 8);
-    const candidates = [];
-    for (let detectionIndex = 0; detectionIndex < frame.detections.length; detectionIndex += 1) {
-        const detection = frame.detections[detectionIndex];
-        if (!detection ||
-            (detection.locked && options.includeLocked === false) ||
-            options.filter?.(detection, detectionIndex) === false) {
-            continue;
+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;
+            }
         }
-        const detectionArea = Math.max(1, rectArea(getDetectionRect(detection)));
-        const pushCandidate = (target, area = detectionArea, geometryIndex) => {
-            candidates.push({
-                area,
-                priority: getPickTargetPriority(target),
-                result: {
-                    detection,
-                    detectionIndex,
-                    frame,
-                    geometryIndex,
-                    mediaTime: frame.mediaTime,
-                    point,
-                    target,
-                },
-                zIndex: detection.zIndex ?? detectionIndex,
-            });
-        };
-        if (detection.rect && containsPoint(detection.rect, point, padding)) {
-            pushCandidate(DetectionPickTarget.Box, rectArea(detection.rect));
+        if (Math.abs(augmented[pivot][column]) < 1e-12) {
+            throw new Error("SORT Kalman covariance is singular.");
         }
-        if (detection.polygon && pointInPolygon(point, detection.polygon.points)) {
-            pushCandidate(DetectionPickTarget.Polygon, Math.max(1, polygonArea(detection.polygon.points)));
+        [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]);
         }
-        if (detection.polyline) {
-            const segmentIndex = findHitSegment(point, detection.polyline.points, polylinePadding);
-            if (segmentIndex !== -1) {
-                pushCandidate(DetectionPickTarget.Polyline, detectionArea, segmentIndex);
+    }
+    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);
             }
-        }
-        if (detection.keypoints) {
-            const keypointIndex = detection.keypoints.points.findIndex((keypoint, index) => detection.keypoints?.visibility?.[index] !==
-                KeypointVisibility.NotLabeled &&
-                Math.hypot(point.x - keypoint.x, point.y - keypoint.y) <=
-                    keypointPadding);
-            if (keypointIndex !== -1) {
-                pushCandidate(DetectionPickTarget.Keypoint, Math.PI * keypointPadding * keypointPadding, keypointIndex);
+            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);
             }
-            else {
-                const edgeIndex = detection.keypoints.edges.findIndex(([fromIndex, toIndex]) => {
-                    const from = detection.keypoints?.points[fromIndex];
-                    const to = detection.keypoints?.points[toIndex];
-                    return Boolean(from &&
-                        to &&
-                        detection.keypoints?.visibility?.[fromIndex] !==
-                            KeypointVisibility.NotLabeled &&
-                        detection.keypoints?.visibility?.[toIndex] !==
-                            KeypointVisibility.NotLabeled &&
-                        distanceToSegment(point, from, to) <= edgePadding);
-                });
-                if (edgeIndex !== -1) {
-                    const [fromIndex, toIndex] = detection.keypoints.edges[edgeIndex];
-                    const from = detection.keypoints.points[fromIndex];
-                    const to = detection.keypoints.points[toIndex];
-                    const edgeArea = Math.max(1, Math.hypot(to.x - from.x, to.y - from.y) * edgePadding * 2);
-                    pushCandidate(DetectionPickTarget.Edge, edgeArea, edgeIndex);
+            // 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 (detection.mask && options.includeMasks !== false) {
-            const decoded = getDecodedMask(detection.mask);
-            const mediaDimensions = options.maskMediaDimensions;
-            const x = Math.floor(mediaDimensions && mediaDimensions.width > 0
-                ? (point.x / mediaDimensions.width) * decoded.width
-                : point.x);
-            const y = Math.floor(mediaDimensions && mediaDimensions.height > 0
-                ? (point.y / mediaDimensions.height) * decoded.height
-                : point.y);
-            if (x >= 0 &&
-                y >= 0 &&
-                x < decoded.width &&
-                y < decoded.height &&
-                decoded.data[y * decoded.width + x]) {
-                pushCandidate(DetectionPickTarget.Mask, getMaskMediaArea(decoded, mediaDimensions));
-            }
+        if (track.trackerId !== undefined) {
+            assignments.set(detection.detectionIndex, track.trackerId);
         }
     }
-    candidates.sort((left, right) => {
-        const priorityDifference = left.priority - right.priority;
-        if (priorityDifference !== 0) {
-            return priorityDifference;
+}
+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 areaDifference = left.area - right.area;
+        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 {
+        height: rect.height,
+        width: rect.width,
+        x: rect.x - rect.width / 2,
+        y: rect.y - rect.height / 2,
+    };
+}
+function topLeftRectToCenterRect(rect) {
+    return {
+        height: rect.height,
+        width: rect.width,
+        x: rect.x + rect.width / 2,
+        y: rect.y + rect.height / 2,
+    };
+}
+function getPointsRect(points) {
+    if (points.length === 0) {
+        return undefined;
+    }
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const point of points) {
+        minX = Math.min(minX, point.x);
+        minY = Math.min(minY, point.y);
+        maxX = Math.max(maxX, point.x);
+        maxY = Math.max(maxY, point.y);
+    }
+    return {
+        height: maxY - minY,
+        width: maxX - minX,
+        x: (minX + maxX) / 2,
+        y: (minY + maxY) / 2,
+    };
+}
+function getDetectionRect(detection) {
+    return (detection.rect ??
+        getPointsRect(detection.polygon?.points ?? []) ??
+        getPointsRect(detection.polyline?.points ?? []) ??
+        getPointsRect(detection.keypoints?.points ?? []));
+}
+function containsPoint(rect, point, padding = 0) {
+    const halfWidth = rect.width / 2;
+    const halfHeight = rect.height / 2;
+    return (point.x >= rect.x - halfWidth - padding &&
+        point.x <= rect.x + halfWidth + padding &&
+        point.y >= rect.y - halfHeight - padding &&
+        point.y <= rect.y + halfHeight + padding);
+}
+function pointInPolygon(point, polygon) {
+    if (polygon.length < 3) {
+        return false;
+    }
+    let inside = false;
+    for (let currentIndex = 0, previousIndex = polygon.length - 1; currentIndex < polygon.length; previousIndex = currentIndex, currentIndex += 1) {
+        const current = polygon[currentIndex];
+        const previous = polygon[previousIndex];
+        const crossesRay = current.y > point.y !== previous.y > point.y &&
+            point.x <
+                ((previous.x - current.x) * (point.y - current.y)) /
+                    (previous.y - current.y) +
+                    current.x;
+        if (crossesRay) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+function distanceToSegment(point, start, end) {
+    const deltaX = end.x - start.x;
+    const deltaY = end.y - start.y;
+    const lengthSquared = deltaX * deltaX + deltaY * deltaY;
+    if (lengthSquared === 0) {
+        return Math.hypot(point.x - start.x, point.y - start.y);
+    }
+    const projection = Math.max(0, Math.min(1, ((point.x - start.x) * deltaX + (point.y - start.y) * deltaY) /
+        lengthSquared));
+    const closestX = start.x + projection * deltaX;
+    const closestY = start.y + projection * deltaY;
+    return Math.hypot(point.x - closestX, point.y - closestY);
+}
+function polygonArea(points) {
+    if (points.length < 3) {
+        return 0;
+    }
+    let twiceArea = 0;
+    for (let index = 0; index < points.length; index += 1) {
+        const current = points[index];
+        const next = points[(index + 1) % points.length];
+        twiceArea += current.x * next.y - next.x * current.y;
+    }
+    return Math.abs(twiceArea) / 2;
+}
+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) {
+        return null;
+    }
+    const padding = Math.max(0, options.padding ?? 0);
+    const polylinePadding = Math.max(0, options.polylinePadding ?? 6);
+    const keypointPadding = Math.max(0, options.keypointPadding ?? 10);
+    const edgePadding = Math.max(0, options.edgePadding ?? 8);
+    const candidates = [];
+    for (let detectionIndex = 0; detectionIndex < frame.detections.length; detectionIndex += 1) {
+        const detection = frame.detections[detectionIndex];
+        if (!detection ||
+            (detection.locked && options.includeLocked === false) ||
+            options.filter?.(detection, detectionIndex) === false) {
+            continue;
+        }
+        const detectionArea = Math.max(1, rectArea(getDetectionRect(detection)));
+        const pushCandidate = (target, area = detectionArea, geometryIndex) => {
+            candidates.push({
+                area,
+                priority: getPickTargetPriority(target),
+                result: {
+                    detection,
+                    detectionIndex,
+                    frame,
+                    geometryIndex,
+                    mediaTime: frame.mediaTime,
+                    point,
+                    target,
+                },
+                zIndex: detection.zIndex ?? detectionIndex,
+            });
+        };
+        if (detection.rect && containsPoint(detection.rect, point, padding)) {
+            pushCandidate(DetectionPickTarget.Box, rectArea(detection.rect));
+        }
+        if (detection.polygon && pointInPolygon(point, detection.polygon.points)) {
+            pushCandidate(DetectionPickTarget.Polygon, Math.max(1, polygonArea(detection.polygon.points)));
+        }
+        if (detection.polyline) {
+            const segmentIndex = findHitSegment(point, detection.polyline.points, polylinePadding);
+            if (segmentIndex !== -1) {
+                pushCandidate(DetectionPickTarget.Polyline, detectionArea, segmentIndex);
+            }
+        }
+        if (detection.keypoints) {
+            const keypointIndex = detection.keypoints.points.findIndex((keypoint, index) => detection.keypoints?.visibility?.[index] !==
+                KeypointVisibility.NotLabeled &&
+                Math.hypot(point.x - keypoint.x, point.y - keypoint.y) <=
+                    keypointPadding);
+            if (keypointIndex !== -1) {
+                pushCandidate(DetectionPickTarget.Keypoint, Math.PI * keypointPadding * keypointPadding, keypointIndex);
+            }
+            else {
+                const edgeIndex = detection.keypoints.edges.findIndex(([fromIndex, toIndex]) => {
+                    const from = detection.keypoints?.points[fromIndex];
+                    const to = detection.keypoints?.points[toIndex];
+                    return Boolean(from &&
+                        to &&
+                        detection.keypoints?.visibility?.[fromIndex] !==
+                            KeypointVisibility.NotLabeled &&
+                        detection.keypoints?.visibility?.[toIndex] !==
+                            KeypointVisibility.NotLabeled &&
+                        distanceToSegment(point, from, to) <= edgePadding);
+                });
+                if (edgeIndex !== -1) {
+                    const [fromIndex, toIndex] = detection.keypoints.edges[edgeIndex];
+                    const from = detection.keypoints.points[fromIndex];
+                    const to = detection.keypoints.points[toIndex];
+                    const edgeArea = Math.max(1, Math.hypot(to.x - from.x, to.y - from.y) * edgePadding * 2);
+                    pushCandidate(DetectionPickTarget.Edge, edgeArea, edgeIndex);
+                }
+            }
+        }
+        if (detection.mask && options.includeMasks !== false) {
+            const decoded = getDecodedMask(detection.mask);
+            const mediaDimensions = options.maskMediaDimensions;
+            const x = Math.floor(mediaDimensions && mediaDimensions.width > 0
+                ? (point.x / mediaDimensions.width) * decoded.width
+                : point.x);
+            const y = Math.floor(mediaDimensions && mediaDimensions.height > 0
+                ? (point.y / mediaDimensions.height) * decoded.height
+                : point.y);
+            if (x >= 0 &&
+                y >= 0 &&
+                x < decoded.width &&
+                y < decoded.height &&
+                decoded.data[y * decoded.width + x]) {
+                pushCandidate(DetectionPickTarget.Mask, getMaskMediaArea(decoded, mediaDimensions));
+            }
+        }
+    }
+    candidates.sort((left, right) => {
+        const priorityDifference = left.priority - right.priority;
+        if (priorityDifference !== 0) {
+            return priorityDifference;
+        }
+        const areaDifference = left.area - right.area;
         if (areaDifference !== 0) {
             return areaDifference;
         }
@@ -1928,6 +3509,29 @@ function createDetectionPickKey(pick) {
         pick.geometryIndex ?? "geometry",
     ].join(":");
 }
+/**
+ * Compares the frame-independent membership of two ordered selections.
+ *
+ * Detection ids retain their runtime type, so numeric `1` and string `"1"`
+ * remain distinct identities. Anonymous detections keep their frame-local
+ * index identity.
+ */
+function haveSameDetectionPickIdentities(current, next) {
+    if (current.length !== next.length) {
+        return false;
+    }
+    return current.every((pick, index) => {
+        const nextPick = next[index];
+        if (!nextPick) {
+            return false;
+        }
+        const id = pick.detection.id;
+        const nextId = nextPick.detection.id;
+        return id === undefined || nextId === undefined
+            ? id === nextId && pick.detectionIndex === nextPick.detectionIndex
+            : typeof id === typeof nextId && id === nextId;
+    });
+}
 function rebaseDetectionPickToFrame(pick, frame) {
     if (!pick || !frame) {
         return null;
@@ -1953,13 +3557,55 @@ function rebaseDetectionPickToFrame(pick, frame) {
         ? rebasedPick
         : null;
 }
+/**
+ * Carries a pick forward onto a different frame of the same timeline.
+ *
+ * Same-frame rebases behave exactly like `rebaseDetectionPickToFrame`. Across
+ * frames, the pick follows its detection only when the detection id is defined
+ * and unique in both frames, so anonymous and duplicate-id detections keep the
+ * per-frame lifetime they have today. Returns `null` when the detection has no
+ * followable identity or has left the frame.
+ */
+function followDetectionPickAcrossFrames(pick, frame) {
+    const rebasedPick = rebaseDetectionPickToFrame(pick, frame);
+    if (rebasedPick || !pick || !frame) {
+        return rebasedPick;
+    }
+    const id = pick.detection.id;
+    if (id === undefined ||
+        !hasUniqueDetectionId(pick.frame, id) ||
+        !hasUniqueDetectionId(frame, id)) {
+        return null;
+    }
+    const detectionIndex = frame.detections.findIndex((detection) => detection.id === id);
+    const detection = frame.detections[detectionIndex];
+    if (!detection) {
+        return null;
+    }
+    return {
+        detection,
+        detectionIndex,
+        frame,
+        geometryIndex: pick.geometryIndex,
+        mediaTime: frame.mediaTime,
+        point: pick.point,
+        target: pick.target,
+    };
+}
 function detectionPickKey(pick) {
     if (pick.detection.id === undefined) {
         return ["anonymous", pick.detectionIndex];
     }
+    const idType = typeof pick.detection.id;
     return hasUniqueDetectionId(pick.frame, pick.detection.id)
-        ? ["id", String(pick.detection.id)]
-        : ["duplicate-id", String(pick.detection.id), "index", pick.detectionIndex];
+        ? ["id", idType, String(pick.detection.id)]
+        : [
+            "duplicate-id",
+            idType,
+            String(pick.detection.id),
+            "index",
+            pick.detectionIndex,
+        ];
 }
 function hasUniqueDetectionId(frame, id) {
     let count = 0;
@@ -2652,17 +4298,46 @@ function resolveStyleValue(value, detection, context) {
         : value;
 }
 
+/**
+ * Resolves the renderer-neutral stroke contract without dropping optional
+ * geometry controls as styles move from public configuration to draw
+ * instructions.
+ *
+ * Keep this as the single normalization point for every built-in style. That
+ * makes additions to `StrokeStyle` deliberate instead of relying on each style
+ * implementation to copy a growing property list correctly.
+ */
+function resolveStrokeStyle(stroke, defaults) {
+    const alignment = stroke?.alignment ?? defaults.alignment;
+    const cap = stroke?.cap ?? defaults.cap;
+    const dash = stroke?.dash ?? defaults.dash;
+    const join = stroke?.join ?? defaults.join;
+    const miterLimit = stroke?.miterLimit ?? defaults.miterLimit;
+    return {
+        alpha: stroke?.alpha ?? defaults.alpha,
+        color: stroke?.color ?? defaults.color,
+        width: stroke?.width ?? defaults.width,
+        ...(alignment === undefined ? {} : { alignment }),
+        ...(cap === undefined ? {} : { cap }),
+        ...(dash === undefined ? {} : { dash }),
+        ...(join === undefined ? {} : { join }),
+        ...(miterLimit === undefined ? {} : { miterLimit }),
+    };
+}
+
+/** 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 BoxStrokeAlignment;
-(function (BoxStrokeAlignment) {
-    BoxStrokeAlignment["Inside"] = "inside";
-    BoxStrokeAlignment["Center"] = "center";
-    BoxStrokeAlignment["Outside"] = "outside";
-})(BoxStrokeAlignment || (BoxStrokeAlignment = {}));
 
 const DEFAULT_BOX_STROKE_ALPHA = 1;
 const DEFAULT_BOX_STROKE_COLOR = 0x00ff66;
@@ -2716,22 +4391,12 @@ class BaseBoxStyle {
         if (stroke === null) {
             return undefined;
         }
-        const resolvedStroke = {
-            alpha: stroke?.alpha ?? DEFAULT_BOX_STROKE_ALPHA,
-            color: stroke?.color ?? DEFAULT_BOX_STROKE_COLOR,
-            width: stroke?.width ?? DEFAULT_BOX_STROKE_WIDTH,
-        };
-        return {
-            ...resolvedStroke,
-            ...(stroke?.alignment === undefined
-                ? {}
-                : { alignment: stroke.alignment }),
-            ...(stroke?.dash === undefined
-                ? context.ephemeral
-                    ? { dash: [6, 4] }
-                    : {}
-                : { dash: stroke.dash }),
-        };
+        return resolveStrokeStyle(stroke, {
+            alpha: DEFAULT_BOX_STROKE_ALPHA,
+            color: DEFAULT_BOX_STROKE_COLOR,
+            ...(context.ephemeral ? { dash: [6, 4] } : {}),
+            width: DEFAULT_BOX_STROKE_WIDTH,
+        });
     }
     resolveFill(detection, context) {
         const fill = resolveStyleValue(this.options.fill, detection, context);
@@ -2745,6 +4410,83 @@ class BaseBoxStyle {
     }
 }
 
+const DEFAULT_CORNER_LENGTH = 20;
+const DEFAULT_CORNER_STROKE = {
+    alpha: 1,
+    cap: "round",
+    color: 0x00ff66,
+    join: "round",
+    width: 2,
+};
+/**
+ * Configurable four-corner decoration derived from a detection rectangle.
+ *
+ * This is the BoxCornerAnnotator-style facade: it keeps the rectangle semantic
+ * and draws only its four open corner segments.
+ */
+class BaseBoxCornerStyle {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    resolve(detection, context) {
+        if (!detection.rect ||
+            context.hidden ||
+            this.options.shouldRender?.(detection, context) === false) {
+            return undefined;
+        }
+        const resolvedLength = resolveStyleValue(this.options.length, detection, context) ??
+            DEFAULT_CORNER_LENGTH;
+        const viewportScale = context.viewportScale && context.viewportScale > 0
+            ? context.viewportScale
+            : 1;
+        const length = Math.min(Math.max(0, resolvedLength / viewportScale), detection.rect.width / 2, detection.rect.height / 2);
+        const stroke = resolveStyleValue(this.options.stroke, detection, context);
+        if (length <= 0 || stroke === null)
+            return undefined;
+        const { height, width, x, y } = detection.rect;
+        const left = x - width / 2;
+        const right = x + width / 2;
+        const top = y - height / 2;
+        const bottom = y + height / 2;
+        const resolvedStroke = resolveStrokeStyle(stroke, DEFAULT_CORNER_STROKE);
+        const openStroke = {
+            alpha: resolvedStroke.alpha,
+            cap: resolvedStroke.cap,
+            color: resolvedStroke.color,
+            dash: resolvedStroke.dash,
+            join: resolvedStroke.join,
+            miterLimit: resolvedStroke.miterLimit,
+            width: resolvedStroke.width,
+        };
+        return {
+            segments: [
+                [
+                    { x: left + length, y: top },
+                    { x: left, y: top },
+                    { x: left, y: top + length },
+                ],
+                [
+                    { x: right - length, y: top },
+                    { x: right, y: top },
+                    { x: right, y: top + length },
+                ],
+                [
+                    { x: left + length, y: bottom },
+                    { x: left, y: bottom },
+                    { x: left, y: bottom - length },
+                ],
+                [
+                    { x: right - length, y: bottom },
+                    { x: right, y: bottom },
+                    { x: right, y: bottom - length },
+                ],
+            ],
+            stroke: openStroke,
+        };
+    }
+}
+
 var FocusTargetMode;
 (function (FocusTargetMode) {
     FocusTargetMode["Hovered"] = "hovered";
@@ -2943,18 +4685,11 @@ class BaseInteractionStyle {
             return undefined;
         }
         const defaults = getStateDefaults(context.state);
-        const resolvedStroke = {
-            alpha: stroke?.alpha ?? defaults.strokeAlpha,
-            color: stroke?.color ?? defaults.strokeColor,
-            width: stroke?.width ?? defaults.strokeWidth,
-        };
-        if (stroke?.alignment !== undefined) {
-            return {
-                ...resolvedStroke,
-                alignment: stroke.alignment,
-            };
-        }
-        return resolvedStroke;
+        return resolveStrokeStyle(stroke, {
+            alpha: defaults.strokeAlpha,
+            color: defaults.strokeColor,
+            width: defaults.strokeWidth,
+        });
     }
     resolveFill(detection, context) {
         const fill = resolveStyleValue(this.options.fill, detection, context);
@@ -3206,6 +4941,115 @@ function createArtifactKey(options) {
     return `base:${color}:${fillAlpha}:${mode}:${serializeStroke(resolveStroke(options.stroke, color, mode))}`;
 }
 
+/**
+ * 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 = {}));
+
+const DEFAULT_FILL = { alpha: 1, color: 0x00ff66 };
+const DEFAULT_STROKE = { alpha: 1, color: 0xffffff, width: 1 };
+const DEFAULT_SIZE = 12;
+/**
+ * Configurable marker renderer style anchored to semantic detection geometry.
+ *
+ * Use `center` for any domain-specific anchor (keypoint, centroid, or custom
+ * metadata). Without it, the marker lands at the detection rectangle center.
+ */
+class BaseMarkerStyle {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    resolve(detection, context) {
+        if (context.hidden ||
+            this.options.shouldRender?.(detection, context) === false) {
+            return undefined;
+        }
+        const center = resolveStyleValue(this.options.center, detection, context) ??
+            (detection.rect
+                ? { x: detection.rect.x, y: detection.rect.y }
+                : undefined);
+        const shape = resolveStyleValue(this.options.shape, detection, context) ??
+            MarkerShape.Circle;
+        const size = resolveStyleValue(this.options.size, detection, context) ?? DEFAULT_SIZE;
+        const sizeSpace = resolveStyleValue(this.options.sizeSpace, detection, context) ??
+            MarkerSizeSpace.Screen;
+        const rotation = resolveStyleValue(this.options.rotation, detection, context);
+        const stroke = resolveStyleValue(this.options.stroke, detection, context);
+        if (!center || !Number.isFinite(size) || size <= 0) {
+            return undefined;
+        }
+        if (shape === MarkerShape.Cross) {
+            if (stroke === null) {
+                return undefined;
+            }
+            const resolvedStroke = resolveStrokeStyle(stroke, DEFAULT_STROKE);
+            const openStroke = {
+                alpha: resolvedStroke.alpha,
+                cap: resolvedStroke.cap,
+                color: resolvedStroke.color,
+                dash: resolvedStroke.dash,
+                join: resolvedStroke.join,
+                miterLimit: resolvedStroke.miterLimit,
+                width: resolvedStroke.width,
+            };
+            return {
+                center,
+                shape,
+                size,
+                sizeSpace,
+                ...(rotation === undefined ? {} : { rotation }),
+                stroke: openStroke,
+            };
+        }
+        const fill = resolveStyleValue(this.options.fill, detection, context);
+        if (fill === null && stroke === null) {
+            return undefined;
+        }
+        return {
+            center,
+            shape,
+            size,
+            sizeSpace,
+            ...(rotation === undefined ? {} : { rotation }),
+            ...(fill === null
+                ? {}
+                : {
+                    fill: {
+                        alpha: fill?.alpha ?? DEFAULT_FILL.alpha,
+                        color: fill?.color ?? DEFAULT_FILL.color,
+                    },
+                }),
+            ...(stroke === null
+                ? {}
+                : stroke === undefined
+                    ? { stroke: DEFAULT_STROKE }
+                    : { stroke: resolveStrokeStyle(stroke, DEFAULT_STROKE) }),
+        };
+    }
+}
+
 class BasePolygonStyle {
     options;
     constructor(options = {}) {
@@ -3233,15 +5077,11 @@ class BasePolygonStyle {
             ...(stroke === null
                 ? {}
                 : {
-                    stroke: {
-                        alpha: stroke?.alpha ?? 1,
-                        color: stroke?.color ?? 0x00ff66,
-                        width: stroke?.width ?? 2,
-                        ...(stroke?.alignment === undefined
-                            ? {}
-                            : { alignment: stroke.alignment }),
-                        ...(stroke?.dash === undefined ? {} : { dash: stroke.dash }),
-                    },
+                    stroke: resolveStrokeStyle(stroke, {
+                        alpha: 1,
+                        color: 0x00ff66,
+                        width: 2,
+                    }),
                 }),
         };
     }
@@ -3265,15 +5105,11 @@ class BasePolylineStyle {
         }
         return {
             points: detection.polyline.points,
-            stroke: {
-                alpha: stroke?.alpha ?? 1,
-                color: stroke?.color ?? 0x00ff66,
-                width: stroke?.width ?? 2,
-                ...(stroke?.alignment === undefined
-                    ? {}
-                    : { alignment: stroke.alignment }),
-                ...(stroke?.dash === undefined ? {} : { dash: stroke.dash }),
-            },
+            stroke: resolveStrokeStyle(stroke, {
+                alpha: 1,
+                color: 0x00ff66,
+                width: 2,
+            }),
         };
     }
 }
@@ -3307,19 +5143,21 @@ class BaseKeypointStyle {
         const edges = geometry.edges.map(([fromIndex, toIndex], edgeIndex) => ({
             from: geometry.points[fromIndex],
             to: geometry.points[toIndex],
-            stroke: {
-                alpha: edgeStroke?.alpha ?? 1,
-                color: definition?.edges[edgeIndex]?.color ?? edgeStroke?.color ?? 0x00ff66,
-                width: edgeStroke?.width ?? 2,
-            },
+            stroke: resolveStrokeStyle(definition?.edges[edgeIndex]?.color === undefined
+                ? edgeStroke
+                : { ...edgeStroke, color: definition.edges[edgeIndex].color }, {
+                alpha: 1,
+                color: 0x00ff66,
+                width: 2,
+            }),
             ...(shadowStroke === null
                 ? {}
                 : {
-                    shadowStroke: {
-                        alpha: shadowStroke?.alpha ?? 0.65,
-                        color: shadowStroke?.color ?? 0x000000,
-                        width: shadowStroke?.width ?? 4,
-                    },
+                    shadowStroke: resolveStrokeStyle(shadowStroke, {
+                        alpha: 0.65,
+                        color: 0x000000,
+                        width: 4,
+                    }),
                 }),
         }));
         const markers = geometry.points.flatMap((point, index) => {
@@ -3341,11 +5179,11 @@ class BaseKeypointStyle {
                     shape: visibility === KeypointVisibility.Occluded
                         ? KeypointMarkerShape.Cross
                         : KeypointMarkerShape.Circle,
-                    stroke: {
-                        alpha: markerStroke?.alpha ?? 1,
-                        color: markerStroke?.color ?? 0xffffff,
-                        width: markerStroke?.width ?? 2,
-                    },
+                    stroke: resolveStrokeStyle(markerStroke, {
+                        alpha: 1,
+                        color: 0xffffff,
+                        width: 2,
+                    }),
                 },
             ];
         });
@@ -3426,6 +5264,9 @@ function createClassColorStyle(fill, labelBackground, labelText, stroke) {
 }
 
 const DEFAULT_BOX_CORNER_RADIUS = 1;
+const DEFAULT_ELLIPSE_AXIS_RATIO = 0.35;
+const DEFAULT_ELLIPSE_START_ANGLE = (-45 * Math.PI) / 180;
+const DEFAULT_ELLIPSE_END_ANGLE = (235 * Math.PI) / 180;
 const DEFAULT_OUTLINE_WIDTH = 2;
 const DEFAULT_FILL_ALPHA = 0.08;
 const DEFAULT_MASK_FILL_ALPHA = 0.45;
@@ -3480,6 +5321,47 @@ function createDefaultBoxStyle(options = {}) {
         }),
     });
 }
+/** Canonical opt-in BoxCornerAnnotator-style presentation. */
+function createDefaultBoxCornerStyle(options = {}) {
+    const getClassColor = createClassColorResolver(options);
+    return new BaseBoxCornerStyle({
+        stroke: (detection) => ({ color: getClassColor(detection) }),
+    });
+}
+/**
+ * Matches the Python Supervision EllipseAnnotator: an elliptical footprint
+ * arc under the detection box, swept from -45deg to 235deg, in the class
+ * color.
+ */
+function createDefaultEllipseStyle(options = {}) {
+    const getClassColor = createClassColorResolver(options);
+    return {
+        resolve(detection, context) {
+            if (!detection.rect || context.hidden) {
+                return undefined;
+            }
+            const radiusX = detection.rect.width / 2;
+            const radiusY = radiusX * DEFAULT_ELLIPSE_AXIS_RATIO;
+            return {
+                center: {
+                    x: detection.rect.x,
+                    // Bottom-tangent so the arc hugs the detection instead of dipping
+                    // below its feet.
+                    y: detection.rect.y + detection.rect.height / 2 - radiusY,
+                },
+                endAngle: DEFAULT_ELLIPSE_END_ANGLE,
+                radiusX,
+                radiusY,
+                startAngle: DEFAULT_ELLIPSE_START_ANGLE,
+                stroke: {
+                    alpha: 1,
+                    color: getClassColor(detection),
+                    width: DEFAULT_OUTLINE_WIDTH,
+                },
+            };
+        },
+    };
+}
 function createDefaultKeypointStyle(options = {}) {
     const getClassColor = createClassColorResolver(options);
     return new BaseKeypointStyle({
@@ -3538,6 +5420,31 @@ function createDefaultMaskStyle(options = {}) {
         }),
     });
 }
+/** Canonical opt-in marker presentation. */
+function createDefaultMarkerStyle() {
+    return new BaseMarkerStyle();
+}
+const DEFAULT_MASK_HALO_ALPHA = 0.6;
+const DEFAULT_MASK_HALO_SPREAD = 12;
+/**
+ * Canonical mask halo: a class-colored glow that follows the mask silhouette.
+ * Used when the `maskHalo` renderer is listed without an explicit style.
+ */
+function createDefaultMaskHaloStyle(options = {}) {
+    const getClassColor = createClassColorResolver(options);
+    return {
+        resolve(detection, context) {
+            if (!detection.mask || context.hidden) {
+                return undefined;
+            }
+            return {
+                alpha: DEFAULT_MASK_HALO_ALPHA,
+                color: getClassColor(detection),
+                spread: DEFAULT_MASK_HALO_SPREAD,
+            };
+        },
+    };
+}
 function createDefaultPolygonStyle(options = {}) {
     const getClassColor = createClassColorResolver(options);
     return new BasePolygonStyle({
@@ -3580,12 +5487,30 @@ function resolveDefaultClassColor(detection, getClassColor) {
  */
 const annotationRendererKinds = [
     "box",
+    "box-corners",
+    "ellipse",
     "keypoints",
     "label",
     "mask",
+    "maskHalo",
+    "marker",
     "polygon",
     "polyline",
+    "region",
 ];
+/** Sources currently supported by a region renderer. */
+const RegionRendererSourceKind = {
+    Asset: "asset",
+};
+/** Media-space regions currently supported by a region renderer. */
+const RegionRendererRegionKind = {
+    Bounds: "bounds",
+    KeypointAnchor: "keypoint-anchor",
+};
+/** Composition modes currently supported by a region renderer. */
+const RegionRendererComposeMode = {
+    Over: "over",
+};
 /**
  * Creates built-in annotation renderer descriptors for
  * `MediaRendererPresentation.renderers`.
@@ -3596,11 +5521,16 @@ const annotationRendererKinds = [
  */
 const annotationRenderers = {
     box: (options) => createAnnotationRenderer("box", options),
+    boxCorners: (options) => createAnnotationRenderer("box-corners", options),
+    ellipse: (options) => createAnnotationRenderer("ellipse", options),
     keypoints: (options) => createAnnotationRenderer("keypoints", options),
     label: (options) => createAnnotationRenderer("label", options),
     mask: (options) => createAnnotationRenderer("mask", options),
+    maskHalo: (options) => createAnnotationRenderer("maskHalo", options),
+    marker: (options) => createAnnotationRenderer("marker", options),
     polygon: (options) => createAnnotationRenderer("polygon", options),
     polyline: (options) => createAnnotationRenderer("polyline", options),
+    region: (options) => ({ kind: "region", ...options }),
 };
 function createAnnotationRenderer(kind, options) {
     // Every built-in renderer keeps its kind as its stable id. TypeScript cannot
@@ -3610,31 +5540,67 @@ function createAnnotationRenderer(kind, options) {
 }
 
 const annotationRendererRegistry = {
-    box: { createCanonicalStyle: createDefaultBoxStyle, styleField: "boxStyle" },
+    box: {
+        cardinality: "singleton",
+        createCanonicalStyle: createDefaultBoxStyle,
+        styleField: "boxStyle",
+    },
+    "box-corners": {
+        cardinality: "singleton",
+        createCanonicalStyle: createDefaultBoxCornerStyle,
+        styleField: "boxCornerStyle",
+    },
+    ellipse: {
+        cardinality: "singleton",
+        createCanonicalStyle: createDefaultEllipseStyle,
+        styleField: "ellipseStyle",
+    },
     keypoints: {
+        cardinality: "singleton",
         createCanonicalStyle: createDefaultKeypointStyle,
         styleField: "keypointStyle",
     },
     label: {
+        cardinality: "singleton",
         createCanonicalStyle: createDefaultLabelStyle,
         styleField: "labelStyle",
     },
     mask: {
+        cardinality: "singleton",
         createCanonicalStyle: createDefaultMaskStyle,
         styleField: "maskStyle",
     },
+    maskHalo: {
+        cardinality: "singleton",
+        createCanonicalStyle: () => createDefaultMaskHaloStyle(),
+        styleField: "maskHaloStyle",
+    },
+    marker: {
+        cardinality: "singleton",
+        createCanonicalStyle: createDefaultMarkerStyle,
+        styleField: "markerStyle",
+    },
     polygon: {
+        cardinality: "singleton",
         createCanonicalStyle: createDefaultPolygonStyle,
         styleField: "polygonStyle",
     },
     polyline: {
+        cardinality: "singleton",
         createCanonicalStyle: createDefaultPolylineStyle,
         styleField: "polylineStyle",
     },
+    region: { cardinality: "multiple" },
 };
+function isStyleBackedAnnotationRendererKind(kind) {
+    return annotationRendererRegistry[kind].cardinality === "singleton";
+}
 /** Presentation fields owned by the given renderer kinds, in the same order. */
 function resolveAnnotationRendererStyleFields(kinds) {
-    return kinds.map((kind) => annotationRendererRegistry[kind].styleField);
+    return kinds.flatMap((kind) => {
+        const metadata = annotationRendererRegistry[kind];
+        return "styleField" in metadata ? [metadata.styleField] : [];
+    });
 }
 
 /**
@@ -3650,9 +5616,13 @@ function resolveAnnotationRendererPresentation(presentation) {
     }
     const resolved = {
         boxStyle: null,
+        boxCornerStyle: null,
+        ellipseStyle: null,
         keypointStyle: null,
         labelStyle: null,
+        maskHaloStyle: null,
         maskStyle: null,
+        markerStyle: null,
         polygonStyle: null,
         polylineStyle: null,
     };
@@ -3663,17 +5633,23 @@ function resolveAnnotationRendererPresentation(presentation) {
             throw new RangeError(`MediaRendererPresentation.renderers contains duplicate renderer id "${renderer.id}".`);
         }
         rendererIds.add(renderer.id);
-        if (rendererKinds.has(renderer.kind)) {
+        if (annotationRendererRegistry[renderer.kind].cardinality === "singleton" &&
+            rendererKinds.has(renderer.kind)) {
             throw new RangeError(`MediaRendererPresentation.renderers contains duplicate renderer kind "${renderer.kind}".`);
         }
         rendererKinds.add(renderer.kind);
-        applyRendererStyle(resolved, presentation, renderer);
+        if (isStyleBackedAnnotationRenderer(renderer)) {
+            applyRendererStyle(resolved, presentation, renderer);
+        }
     }
     return {
         ...presentation,
         ...resolved,
     };
 }
+function isStyleBackedAnnotationRenderer(renderer) {
+    return isStyleBackedAnnotationRendererKind(renderer.kind);
+}
 function applyRendererStyle(resolved, configured, renderer) {
     const { createCanonicalStyle, styleField } = annotationRendererRegistry[renderer.kind];
     const configuredStyle = configured[styleField];
@@ -3703,12 +5679,24 @@ function createSourceAwarePresentation(globalPresentation = {}, sources, options
         boxStyle: shouldApplySourceStyle("boxStyle")
             ? new SourceAwareBoxStyle(normalizeGlobalBoxStyle(globalPresentation.boxStyle), sourcePresentations)
             : globalPresentation.boxStyle,
+        boxCornerStyle: shouldApplySourceStyle("boxCornerStyle")
+            ? new SourceAwareBoxCornerStyle(globalPresentation.boxCornerStyle ?? null, sourcePresentations)
+            : globalPresentation.boxCornerStyle,
+        ellipseStyle: shouldApplySourceStyle("ellipseStyle")
+            ? new SourceAwareEllipseStyle(globalPresentation.ellipseStyle ?? null, sourcePresentations)
+            : globalPresentation.ellipseStyle,
         labelStyle: shouldApplySourceStyle("labelStyle")
             ? new SourceAwareLabelStyle(normalizeGlobalLabelStyle(globalPresentation.labelStyle), sourcePresentations)
             : globalPresentation.labelStyle,
         maskStyle: shouldApplySourceStyle("maskStyle")
             ? new SourceAwareMaskStyle(normalizeGlobalMaskStyle(globalPresentation.maskStyle), sourcePresentations)
             : globalPresentation.maskStyle,
+        markerStyle: shouldApplySourceStyle("markerStyle")
+            ? new SourceAwareMarkerStyle(normalizeGlobalMarkerStyle(globalPresentation.markerStyle), sourcePresentations)
+            : globalPresentation.markerStyle,
+        maskHaloStyle: shouldApplySourceStyle("maskHaloStyle")
+            ? new SourceAwareMaskHaloStyle(normalizeGlobalMaskHaloStyle(globalPresentation.maskHaloStyle), sourcePresentations)
+            : globalPresentation.maskHaloStyle,
         polygonStyle: shouldApplySourceStyle("polygonStyle")
             ? new SourceAwarePolygonStyle(normalizeGlobalPolygonStyle(globalPresentation.polygonStyle), sourcePresentations)
             : globalPresentation.polygonStyle,
@@ -3720,58 +5708,7 @@ function createSourceAwarePresentation(globalPresentation = {}, sources, options
             : globalPresentation.keypointStyle,
     };
 }
-class SourceAwareBoxStyle {
-    globalStyle;
-    sourcePresentations;
-    constructor(globalStyle, sourcePresentations) {
-        this.globalStyle = globalStyle;
-        this.sourcePresentations = sourcePresentations;
-    }
-    resolve(detection, context) {
-        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "boxStyle");
-        return style?.resolve(detection, context);
-    }
-}
-class SourceAwareLabelStyle {
-    globalStyle;
-    sourcePresentations;
-    constructor(globalStyle, sourcePresentations) {
-        this.globalStyle = globalStyle;
-        this.sourcePresentations = sourcePresentations;
-    }
-    resolve(detection, context) {
-        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "labelStyle");
-        return style?.resolve(detection, context);
-    }
-}
-class SourceAwareMaskStyle {
-    globalStyle;
-    sourcePresentations;
-    artifactKey = undefined;
-    opacity;
-    constructor(globalStyle, sourcePresentations) {
-        this.globalStyle = globalStyle;
-        this.sourcePresentations = sourcePresentations;
-        this.opacity = globalStyle?.opacity;
-    }
-    resolve(detection, context) {
-        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "maskStyle");
-        return style?.resolve(detection, context);
-    }
-}
-class SourceAwarePolygonStyle {
-    globalStyle;
-    sourcePresentations;
-    constructor(globalStyle, sourcePresentations) {
-        this.globalStyle = globalStyle;
-        this.sourcePresentations = sourcePresentations;
-    }
-    resolve(detection, context) {
-        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "polygonStyle");
-        return style?.resolve(detection, context);
-    }
-}
-class SourceAwarePolylineStyle {
+class SourceAwareBoxCornerStyle {
     globalStyle;
     sourcePresentations;
     constructor(globalStyle, sourcePresentations) {
@@ -3779,11 +5716,10 @@ class SourceAwarePolylineStyle {
         this.sourcePresentations = sourcePresentations;
     }
     resolve(detection, context) {
-        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "polylineStyle");
-        return style?.resolve(detection, context);
+        return resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "boxCornerStyle")?.resolve(detection, context);
     }
 }
-class SourceAwareKeypointStyle {
+class SourceAwareBoxStyle {
     globalStyle;
     sourcePresentations;
     constructor(globalStyle, sourcePresentations) {
@@ -3791,274 +5727,143 @@ class SourceAwareKeypointStyle {
         this.sourcePresentations = sourcePresentations;
     }
     resolve(detection, context) {
-        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "keypointStyle");
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "boxStyle");
         return style?.resolve(detection, context);
     }
-}
-function hasSourceStyle(sources, key) {
-    return sources.some((source) => source.presentation?.[key] !== undefined);
-}
-function resolveSourceStyle(detection, globalStyle, sourcePresentations, key) {
-    const sourcePresentation = detection.sourceId
-        ? sourcePresentations.get(detection.sourceId)
-        : undefined;
-    const sourceStyle = sourcePresentation?.[key];
-    return sourceStyle === undefined ? globalStyle : sourceStyle;
-}
-function normalizeGlobalBoxStyle(style) {
-    return style === undefined ? new BaseBoxStyle() : style;
-}
-function normalizeGlobalLabelStyle(style) {
-    return style === undefined ? new BaseLabelStyle() : style;
-}
-function normalizeGlobalMaskStyle(style) {
-    return style === undefined ? new BaseMaskStyle() : style;
-}
-function normalizeGlobalPolygonStyle(style) {
-    return style === undefined ? new BasePolygonStyle() : style;
-}
-function normalizeGlobalPolylineStyle(style) {
-    return style === undefined ? new BasePolylineStyle() : style;
-}
-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;
+}
+class SourceAwareEllipseStyle {
+    globalStyle;
+    sourcePresentations;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
+    }
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "ellipseStyle");
+        return style?.resolve(detection, context);
     }
-    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;
+class SourceAwareLabelStyle {
+    globalStyle;
+    sourcePresentations;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
+    }
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "labelStyle");
+        return style?.resolve(detection, context);
+    }
 }
-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;
-            }
-        }
+class SourceAwareMaskStyle {
+    globalStyle;
+    sourcePresentations;
+    artifactKey = undefined;
+    opacity;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
+        this.opacity = globalStyle?.opacity;
+    }
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "maskStyle");
+        return style?.resolve(detection, context);
     }
-    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 });
-        }
+class SourceAwareMaskHaloStyle {
+    globalStyle;
+    sourcePresentations;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
+    }
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "maskHaloStyle");
+        return style?.resolve(detection, context);
     }
-    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);
-            }
-        }
+class SourceAwareMarkerStyle {
+    globalStyle;
+    sourcePresentations;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
+    }
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "markerStyle");
+        return style?.resolve(detection, context);
     }
-    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.");
+class SourceAwarePolygonStyle {
+    globalStyle;
+    sourcePresentations;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
     }
-    if (!Number.isInteger(height) || height <= 0) {
-        throw new Error("Mask height must be a positive integer.");
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "polygonStyle");
+        return style?.resolve(detection, context);
     }
-    if (data.length !== width * height) {
-        throw new Error("Mask data length must equal width * height.");
+}
+class SourceAwarePolylineStyle {
+    globalStyle;
+    sourcePresentations;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
+    }
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "polylineStyle");
+        return style?.resolve(detection, context);
+    }
+}
+class SourceAwareKeypointStyle {
+    globalStyle;
+    sourcePresentations;
+    constructor(globalStyle, sourcePresentations) {
+        this.globalStyle = globalStyle;
+        this.sourcePresentations = sourcePresentations;
+    }
+    resolve(detection, context) {
+        const style = resolveSourceStyle(detection, this.globalStyle, this.sourcePresentations, "keypointStyle");
+        return style?.resolve(detection, context);
     }
 }
+function hasSourceStyle(sources, key) {
+    return sources.some((source) => source.presentation?.[key] !== undefined);
+}
+function resolveSourceStyle(detection, globalStyle, sourcePresentations, key) {
+    const sourcePresentation = detection.sourceId
+        ? sourcePresentations.get(detection.sourceId)
+        : undefined;
+    const sourceStyle = sourcePresentation?.[key];
+    return sourceStyle === undefined ? globalStyle : sourceStyle;
+}
+function normalizeGlobalBoxStyle(style) {
+    return style === undefined ? new BaseBoxStyle() : style;
+}
+function normalizeGlobalLabelStyle(style) {
+    return style === undefined ? new BaseLabelStyle() : style;
+}
+function normalizeGlobalMaskStyle(style) {
+    return style === undefined ? new BaseMaskStyle() : style;
+}
+function normalizeGlobalMaskHaloStyle(style) {
+    return style === undefined ? createDefaultMaskHaloStyle() : style;
+}
+function normalizeGlobalMarkerStyle(style) {
+    return style === undefined ? new BaseMarkerStyle() : style;
+}
+function normalizeGlobalPolygonStyle(style) {
+    return style === undefined ? new BasePolygonStyle() : style;
+}
+function normalizeGlobalPolylineStyle(style) {
+    return style === undefined ? new BasePolylineStyle() : style;
+}
+function normalizeGlobalKeypointStyle(style) {
+    return style === undefined ? new BaseKeypointStyle() : style;
+}
 
 function rectToPolygon(rect) {
     const halfWidth = rect.width / 2;
@@ -4310,6 +6115,180 @@ function writePaletteEntry(palette, id, color, alpha) {
     palette[offset + 3] = Math.max(0, Math.min(alpha, 1));
 }
 
+const DEFAULT_ELLIPSE_SEGMENT_COUNT = 48;
+const FULL_TURN = Math.PI * 2;
+const GEOMETRY_EPSILON = 1e-9;
+const MIN_ELLIPSE_SEGMENT_COUNT = 4;
+const MAX_ELLIPSE_SEGMENT_COUNT = 512;
+/**
+ * Samples an ellipse or elliptical arc into a deterministic polyline so every
+ * backend rasterizes the same structural geometry, including dashed strokes.
+ *
+ * A closed ellipse returns `segmentCount` points without repeating the first
+ * point; an open arc returns `segmentCount + 1` points including both
+ * endpoints.
+ */
+function sampleEllipseArc(ellipse, segmentCount = DEFAULT_ELLIPSE_SEGMENT_COUNT) {
+    validateEllipseGeometry(ellipse);
+    assertIntegerAtLeast(segmentCount, MIN_ELLIPSE_SEGMENT_COUNT, "segmentCount");
+    const rotation = ellipse.rotation ?? 0;
+    const startAngle = ellipse.startAngle ?? 0;
+    const endAngle = ellipse.endAngle ?? startAngle + FULL_TURN;
+    const range = endAngle - startAngle;
+    const closed = ellipse.startAngle === undefined;
+    const pointCount = closed ? segmentCount : segmentCount + 1;
+    const cosRotation = Math.cos(rotation);
+    const sinRotation = Math.sin(rotation);
+    const points = [];
+    for (let index = 0; index < pointCount; index += 1) {
+        const angle = startAngle + (range * index) / segmentCount;
+        const localX = Math.cos(angle) * ellipse.radiusX;
+        const localY = Math.sin(angle) * ellipse.radiusY;
+        points.push({
+            x: ellipse.center.x + localX * cosRotation - localY * sinRotation,
+            y: ellipse.center.y + localX * sinRotation + localY * cosRotation,
+        });
+    }
+    return { closed, points };
+}
+/**
+ * Chooses a bounded segment count from the ellipse's on-screen radius. The
+ * result targets sub-pixel chord error without making tiny markers expensive.
+ */
+function resolveEllipseSegmentCount(ellipse, viewportScale = 1, maxErrorPixels = 0.5) {
+    validateEllipseGeometry(ellipse);
+    assertPositiveFinite(viewportScale, "viewportScale");
+    assertPositiveFinite(maxErrorPixels, "maxErrorPixels");
+    const screenRadius = Math.max(ellipse.radiusX, ellipse.radiusY) * viewportScale;
+    assertPositiveFinite(screenRadius, "screenRadius");
+    const clampedError = Math.min(maxErrorPixels, screenRadius);
+    const maxStep = clampedError === screenRadius
+        ? Math.PI / 2
+        : 2 * Math.acos(1 - clampedError / screenRadius);
+    const startAngle = ellipse.startAngle ?? 0;
+    const endAngle = ellipse.endAngle ?? startAngle + FULL_TURN;
+    const arcLength = Math.abs(endAngle - startAngle);
+    const segmentCount = Math.ceil(arcLength / maxStep);
+    return Math.min(MAX_ELLIPSE_SEGMENT_COUNT, Math.max(MIN_ELLIPSE_SEGMENT_COUNT, segmentCount));
+}
+/**
+ * Resolves a marker instruction into media-space geometry. Screen-space sizes
+ * are divided by the viewport scale, matching stroke-width semantics.
+ */
+function resolveMarkerGeometry(marker, viewportScale = 1) {
+    assertFinitePoint(marker.center, "center");
+    assertPositiveFinite(marker.size, "size");
+    assertPositiveFinite(viewportScale, "viewportScale");
+    if (marker.rotation !== undefined) {
+        assertFinite(marker.rotation, "rotation");
+    }
+    const size = marker.sizeSpace === MarkerSizeSpace.Screen
+        ? marker.size / viewportScale
+        : marker.size;
+    const radius = size / 2;
+    const rotation = marker.rotation ?? 0;
+    if (marker.shape === MarkerShape.Circle) {
+        return { center: marker.center, kind: "circle", radius };
+    }
+    if (marker.shape === MarkerShape.Cross) {
+        return {
+            closed: false,
+            kind: "subpaths",
+            subpaths: [
+                [
+                    rotatePoint(marker.center, -radius, -radius, rotation),
+                    rotatePoint(marker.center, radius, radius, rotation),
+                ],
+                [
+                    rotatePoint(marker.center, radius, -radius, rotation),
+                    rotatePoint(marker.center, -radius, radius, rotation),
+                ],
+            ],
+        };
+    }
+    if (marker.shape === MarkerShape.Square) {
+        return {
+            closed: true,
+            kind: "subpaths",
+            subpaths: [
+                [
+                    rotatePoint(marker.center, -radius, -radius, rotation),
+                    rotatePoint(marker.center, radius, -radius, rotation),
+                    rotatePoint(marker.center, radius, radius, rotation),
+                    rotatePoint(marker.center, -radius, radius, rotation),
+                ],
+            ],
+        };
+    }
+    // Triangle: equilateral, inscribed in the marker circle, pointing toward
+    // positive y at rotation 0.
+    const baseOffsetY = -radius / 2;
+    const baseOffsetX = radius * (Math.sqrt(3) / 2);
+    return {
+        closed: true,
+        kind: "subpaths",
+        subpaths: [
+            [
+                rotatePoint(marker.center, 0, radius, rotation),
+                rotatePoint(marker.center, baseOffsetX, baseOffsetY, rotation),
+                rotatePoint(marker.center, -baseOffsetX, baseOffsetY, rotation),
+            ],
+        ],
+    };
+}
+function validateEllipseGeometry(ellipse) {
+    assertFinitePoint(ellipse.center, "center");
+    assertPositiveFinite(ellipse.radiusX, "radiusX");
+    assertPositiveFinite(ellipse.radiusY, "radiusY");
+    if (ellipse.rotation !== undefined) {
+        assertFinite(ellipse.rotation, "rotation");
+    }
+    const hasStart = ellipse.startAngle !== undefined;
+    const hasEnd = ellipse.endAngle !== undefined;
+    if (hasStart !== hasEnd) {
+        throw new RangeError("startAngle and endAngle must be provided together");
+    }
+    if (hasStart && hasEnd) {
+        assertFinite(ellipse.startAngle, "startAngle");
+        assertFinite(ellipse.endAngle, "endAngle");
+        const range = Math.abs(ellipse.endAngle - ellipse.startAngle);
+        if (range <= GEOMETRY_EPSILON || range >= FULL_TURN - GEOMETRY_EPSILON) {
+            throw new RangeError("ellipse arc range must be greater than 0 and less than one full turn");
+        }
+    }
+}
+function assertFinitePoint(point, name) {
+    assertFinite(point.x, `${name}.x`);
+    assertFinite(point.y, `${name}.y`);
+}
+function assertFinite(value, name) {
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`${name} must be finite`);
+    }
+}
+function assertPositiveFinite(value, name) {
+    assertFinite(value, name);
+    if (value <= 0) {
+        throw new RangeError(`${name} must be greater than 0`);
+    }
+}
+function assertIntegerAtLeast(value, minimum, name) {
+    if (!Number.isInteger(value) || value < minimum) {
+        throw new RangeError(`${name} must be an integer of at least ${minimum}`);
+    }
+}
+function rotatePoint(center, offsetX, offsetY, rotation) {
+    if (rotation === 0) {
+        return { x: center.x + offsetX, y: center.y + offsetY };
+    }
+    const cosRotation = Math.cos(rotation);
+    const sinRotation = Math.sin(rotation);
+    return {
+        x: center.x + offsetX * cosRotation - offsetY * sinRotation,
+        y: center.y + offsetX * sinRotation + offsetY * cosRotation,
+    };
+}
+
 function includeDefined(values) {
     return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
 }
@@ -4426,5 +6405,5 @@ var MediaSessionActivityStatus;
     MediaSessionActivityStatus["Waiting"] = "waiting";
 })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));
 
-export { AnnotationFrameMutationKind, AnnotationGeometryKind, AnnotationGestureStateKind, AnnotationHandleKind, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, 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, MaskRenderMode, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, SUPERVISION_ROBOFLOW_COLOR, 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, getAnnotationHandles, getBufferedDetectionTimelineFrameSnapshot, getDetectionRect, getPointsRect, includeDefined, isDeflatedBase64DetectionMaskPayload, lightenColor, mediaToScreen, mergeDetectionMasks, mergeDetectionPolygonsByClass, normalizeDetectionClassName, offsetDetection, pickAnnotationHandle, pickDetectionAtPoint, pickDetectionByMaskId, pointInPolygon, polygonArea, polygonToRect, rasterizePolygonToMask, rasterizeRectToMask, rebaseDetectionPickToFrame, rectArea, rectToPolygon, resolveAnnotationRendererPresentation, resolveAnnotationStyleState, resolveContrastTextColor, resolveDetectionClassColorStyle, resolveMaskStyleOpacity, resolveStyleValue, 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