supervision 0.1.4 → 0.1.6

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

@@ -88,6 +88,9 @@ function copySortedDetectionFrames(detectionFrames) {
                 : undefined,
             rect: detection.rect ? { ...detection.rect } : undefined,
         })),
+        coordinateSpace: frame.coordinateSpace
+            ? { ...frame.coordinateSpace }
+            : undefined,
         endTime: frame.endTime,
         frameIndex: frame.frameIndex,
         mediaTime: frame.mediaTime,
@@ -129,6 +132,10 @@ function validateDetectionFrames(detectionFrames) {
                 min: 0,
             });
         }
+        if (frame.coordinateSpace !== undefined) {
+            validateNumber(frame.coordinateSpace.width, `frames[${frameOffset}].coordinateSpace.width`, { exclusiveMin: 0 });
+            validateNumber(frame.coordinateSpace.height, `frames[${frameOffset}].coordinateSpace.height`, { exclusiveMin: 0 });
+        }
         for (const [detectionOffset, detection] of frame.detections.entries()) {
             const detectionPath = `frames[${frameOffset}].detections[${detectionOffset}]`;
             if (detection.confidence !== undefined) {
@@ -140,6 +147,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.`);
@@ -882,7 +895,7 @@ function mergeIncrementalFrames(currentFrames, changedFrames, changedRanges) {
     for (const frame of changedFrames) {
         framesByIdentity.set(getDetectionFrameIdentity(frame), frame);
     }
-    return Array.from(framesByIdentity.values()).sort(compareDetectionFrames);
+    return Array.from(framesByIdentity.values()).sort(compareDetectionFrames$1);
 }
 function reuseBufferedFrameSnapshots(currentFrames, loadedFrames) {
     const currentFramesByIdentity = new Map(currentFrames.map((frame) => [getDetectionFrameIdentity(frame), frame]));
@@ -893,7 +906,7 @@ function getDetectionFrameIdentity(frame) {
         ? `time:${frame.mediaTime}`
         : `index:${frame.frameIndex}`;
 }
-function compareDetectionFrames(left, right) {
+function compareDetectionFrames$1(left, right) {
     if (left.mediaTime !== right.mediaTime) {
         return left.mediaTime - right.mediaTime;
     }
@@ -912,21 +925,118 @@ function createColdDetectionFrameSource(options) {
     };
 }
 
+/**
+ * Projects one detection frame from its declared source coordinate space into
+ * `target`.
+ *
+ * Rectangles, polygons, polylines, and keypoints are scaled. Masks are left
+ * untouched because a `DetectionMask` already carries the mask-pixel
+ * dimensions its `counts` are encoded against; scaling them here would apply
+ * the ratio twice. Frames without `coordinateSpace`, with a degenerate space,
+ * or already in the target space are returned unchanged so mixed producers can
+ * share one source.
+ */
+function projectDetectionFrame(frame, target) {
+    const space = frame.coordinateSpace;
+    if (!space ||
+        !isUsableCoordinateSpace(space) ||
+        !isUsableCoordinateSpace(target) ||
+        (space.width === target.width && space.height === target.height)) {
+        return frame;
+    }
+    const scaleX = target.width / space.width;
+    const scaleY = target.height / space.height;
+    return {
+        ...frame,
+        coordinateSpace: { height: target.height, width: target.width },
+        detections: frame.detections.map((detection) => projectDetection(detection, scaleX, scaleY)),
+    };
+}
+/**
+ * Projects every frame that declares a source coordinate space into `target`.
+ *
+ * Frames without coordinate metadata pass through by reference.
+ */
+function projectDetectionFrames(frames, target) {
+    let didProject = false;
+    const projectedFrames = frames.map((frame) => {
+        const projectedFrame = projectDetectionFrame(frame, target);
+        didProject ||= projectedFrame !== frame;
+        return projectedFrame;
+    });
+    return didProject ? projectedFrames : frames;
+}
+function projectDetection(detection, scaleX, scaleY) {
+    return {
+        ...detection,
+        ...(detection.rect
+            ? { rect: scaleRect(detection.rect, scaleX, scaleY) }
+            : {}),
+        ...(detection.polygon
+            ? { polygon: scalePolygon(detection.polygon, scaleX, scaleY) }
+            : {}),
+        ...(detection.polyline
+            ? { polyline: scalePolyline(detection.polyline, scaleX, scaleY) }
+            : {}),
+        ...(detection.keypoints
+            ? { keypoints: scaleKeypoints(detection.keypoints, scaleX, scaleY) }
+            : {}),
+    };
+}
+function scaleRect(rect, scaleX, scaleY) {
+    return {
+        height: rect.height * scaleY,
+        width: rect.width * scaleX,
+        x: rect.x * scaleX,
+        y: rect.y * scaleY,
+    };
+}
+function scalePolygon(polygon, scaleX, scaleY) {
+    return { points: scalePoints(polygon.points, scaleX, scaleY) };
+}
+function scalePolyline(polyline, scaleX, scaleY) {
+    return { points: scalePoints(polyline.points, scaleX, scaleY) };
+}
+function scaleKeypoints(keypoints, scaleX, scaleY) {
+    return {
+        ...keypoints,
+        points: scalePoints(keypoints.points, scaleX, scaleY),
+    };
+}
+function scalePoints(points, scaleX, scaleY) {
+    return points.map((point) => ({ x: point.x * scaleX, y: point.y * scaleY }));
+}
+function isUsableCoordinateSpace(space) {
+    return (Number.isFinite(space.width) &&
+        Number.isFinite(space.height) &&
+        space.width > 0 &&
+        space.height > 0);
+}
+
 function createCompositeDetectionFrameSource(options) {
     const sources = normalizeCompositeSources(options.sources);
     return {
-        async loadFrames(startTime, endTime) {
-            const loadedSources = await Promise.all(sources.map(async (source) => ({
-                ...source,
-                frames: copySortedDetectionFrames(await source.source.loadFrames(startTime, endTime)),
-            })));
+        async loadFrames(startTime, endTime, loadOptions) {
+            const target = loadOptions?.coordinateSpace;
+            const loadedSources = await Promise.all(sources.map(async (source) => {
+                const frames = copySortedDetectionFrames(await source.source.loadFrames(startTime, endTime, loadOptions));
+                return {
+                    ...source,
+                    // Composition flattens child detections into one frame, which can
+                    // only carry one coordinate space. Each child is projected here,
+                    // while its own `coordinateSpace` is still attached to its own
+                    // detections, so children inferred at different sizes compose
+                    // correctly. Masks keep their intrinsic dimensions.
+                    frames: target ? projectDetectionFrames(frames, target) : frames,
+                };
+            }));
             if (options.selectionMode === DetectionFrameSelectionMode.NearestFrameIndex) {
-                const nearestFrames = composeNearestFrameIndexFrames(loadedSources, startTime, endTime, options);
+                const nearestFrames = composeNearestFrameIndexFrames(loadedSources, startTime, endTime, options, target);
                 if (nearestFrames) {
                     return nearestFrames;
                 }
             }
-            return composeIntervalFrames(loadedSources, startTime, endTime, options);
+            return composeIntervalFrames(loadedSources, startTime, endTime, options, target);
         },
         async waitForRange(range) {
             await Promise.all(sources
@@ -973,7 +1083,7 @@ function normalizeCompositeSources(entries) {
         .sort((left, right) => left.order - right.order ||
         left.declarationIndex - right.declarationIndex);
 }
-function composeIntervalFrames(sources, startTime, endTime, options) {
+function composeIntervalFrames(sources, startTime, endTime, options, coordinateSpace) {
     const boundaryTimes = new Set([startTime]);
     for (const source of sources) {
         for (const frame of source.frames) {
@@ -995,17 +1105,14 @@ function composeIntervalFrames(sources, startTime, endTime, options) {
         }
         const nextBoundaryTime = sortedBoundaryTimes[boundaryIndex + 1] ?? endTime;
         const endTimeForFrame = Math.min(nextBoundaryTime, endTime);
-        const frame = composeFrameAtTime(sources, mediaTime, endTimeForFrame, {
-            ...options,
-            selectionMode: DetectionFrameSelectionMode.Interval,
-        });
+        const frame = composeFrameAtTime(sources, mediaTime, endTimeForFrame, { ...options, selectionMode: DetectionFrameSelectionMode.Interval }, undefined, coordinateSpace);
         if (frame) {
             frames.push(frame);
         }
     }
     return frames;
 }
-function composeNearestFrameIndexFrames(sources, startTime, endTime, options) {
+function composeNearestFrameIndexFrames(sources, startTime, endTime, options, coordinateSpace) {
     const frameRate = options.frameRate;
     if (!frameRate || !Number.isFinite(frameRate) || frameRate <= 0) {
         return null;
@@ -1031,14 +1138,14 @@ function composeNearestFrameIndexFrames(sources, startTime, endTime, options) {
         const frame = composeFrameAtTime(sources, mediaTime, Math.min(mediaTime + 1 / frameRate, endTime), {
             ...options,
             selectionMode: DetectionFrameSelectionMode.NearestFrameIndex,
-        }, frameIndex);
+        }, frameIndex, coordinateSpace);
         if (frame) {
             frames.push(frame);
         }
     }
     return frames;
 }
-function composeFrameAtTime(sources, mediaTime, endTime, options, frameIndex) {
+function composeFrameAtTime(sources, mediaTime, endTime, options, frameIndex, coordinateSpace) {
     const detections = [];
     const activeFrameIndexes = [];
     for (const source of sources) {
@@ -1064,6 +1171,9 @@ function composeFrameAtTime(sources, mediaTime, endTime, options, frameIndex) {
         endTime,
         frameIndex: frameIndex ?? resolveComposedFrameIndex(activeFrameIndexes) ?? undefined,
         mediaTime,
+        // Children were projected before composition, so a composed frame is
+        // already in the coordinate space the renderer presents.
+        ...(coordinateSpace ? { coordinateSpace } : {}),
     };
 }
 function copyDetectionWithSource(detection, sourceId, sourceDetectionIndex) {
@@ -1278,6 +1388,16 @@ function createMemoryColdDetectionFrameStore() {
                 detectionFrameOverlapsRange(frame, startTime, endTime));
             return copySortedDetectionFrames(frames);
         },
+        async pruneFrames(options) {
+            assertActive();
+            assertRetentionFloor(options.startTime);
+            const dataset = datasets.get(options.datasetId);
+            if (!dataset) {
+                return createWriteSummary(options.datasetId, createDataset(DEFAULT_CHUNK_DURATION_SECONDS));
+            }
+            pruneDatasetBefore(dataset, options.startTime);
+            return createWriteSummary(options.datasetId, dataset);
+        },
         async clearDataset(datasetId) {
             assertActive();
             datasets.delete(datasetId);
@@ -1316,7 +1436,7 @@ function upsertFrames(dataset, frames) {
         dataset.framesByKey.set(frameKey, { chunkIndexes, frame });
         dataset.detectionCount += frame.detections.length;
         dataset.startTime = Math.min(dataset.startTime ?? frame.mediaTime, frame.mediaTime);
-        dataset.endTime = Math.max(dataset.endTime ?? getFrameEndTime(frame), getFrameEndTime(frame));
+        dataset.endTime = Math.max(dataset.endTime ?? getFrameEndTime$1(frame), getFrameEndTime$1(frame));
         for (const chunkIndex of chunkIndexes) {
             const frameKeys = dataset.frameKeysByChunk.get(chunkIndex) ?? new Set();
             frameKeys.add(frameKey);
@@ -1338,18 +1458,81 @@ function removeStoredFrame(dataset, frameKey, storedFrame) {
         }
     }
 }
+/**
+ * Drops frames that end before `startTime`.
+ *
+ * Only chunks at or below the retention boundary are visited, and the new
+ * start bound is read from the lowest surviving chunk, so eviction costs work
+ * proportional to the evicted range rather than to retained history.
+ */
+function pruneDatasetBefore(dataset, startTime) {
+    const boundaryChunkIndex = getChunkIndex(Math.max(0, startTime), dataset.chunkDurationSeconds);
+    let didRemoveFrame = false;
+    for (const chunkIndex of Array.from(dataset.frameKeysByChunk.keys())) {
+        if (chunkIndex > boundaryChunkIndex) {
+            continue;
+        }
+        for (const frameKey of Array.from(dataset.frameKeysByChunk.get(chunkIndex) ?? [])) {
+            const storedFrame = dataset.framesByKey.get(frameKey);
+            if (!storedFrame || isFrameRetainedFrom(storedFrame.frame, startTime)) {
+                continue;
+            }
+            removeStoredFrame(dataset, frameKey, storedFrame);
+            didRemoveFrame = true;
+        }
+    }
+    if (!didRemoveFrame) {
+        return;
+    }
+    if (dataset.framesByKey.size === 0) {
+        dataset.startTime = null;
+        dataset.endTime = null;
+        return;
+    }
+    // Every frame is registered in the chunk its `mediaTime` falls in, so the
+    // earliest retained frame lives in the lowest remaining chunk. Removing
+    // frames can only raise the start bound; `endTime` is unchanged because only
+    // frames ending before `startTime` were dropped.
+    dataset.startTime = getEarliestChunkStartTime(dataset);
+}
+/**
+ * Mirrors `detectionFrameOverlapsRange` so pruning keeps exactly the frames a
+ * load from `startTime` would return.
+ */
+function isFrameRetainedFrom(frame, startTime) {
+    return frame.endTime === undefined
+        ? frame.mediaTime >= startTime
+        : frame.endTime > startTime;
+}
+function getEarliestChunkStartTime(dataset) {
+    let earliestChunkIndex = null;
+    for (const chunkIndex of dataset.frameKeysByChunk.keys()) {
+        if (earliestChunkIndex === null || chunkIndex < earliestChunkIndex) {
+            earliestChunkIndex = chunkIndex;
+        }
+    }
+    let startTime = null;
+    for (const frameKey of dataset.frameKeysByChunk.get(earliestChunkIndex ?? 0) ?? []) {
+        const storedFrame = dataset.framesByKey.get(frameKey);
+        if (!storedFrame) {
+            continue;
+        }
+        startTime = Math.min(startTime ?? storedFrame.frame.mediaTime, storedFrame.frame.mediaTime);
+    }
+    return startTime;
+}
 function replacementCanShrinkBounds(dataset, previousFrame, nextFrame) {
     return ((dataset.startTime === previousFrame.mediaTime &&
         nextFrame.mediaTime > previousFrame.mediaTime) ||
-        (dataset.endTime === getFrameEndTime(previousFrame) &&
-            getFrameEndTime(nextFrame) < getFrameEndTime(previousFrame)));
+        (dataset.endTime === getFrameEndTime$1(previousFrame) &&
+            getFrameEndTime$1(nextFrame) < getFrameEndTime$1(previousFrame)));
 }
 function recalculateBounds(dataset) {
     let startTime = null;
     let endTime = null;
     for (const { frame } of dataset.framesByKey.values()) {
         startTime = Math.min(startTime ?? frame.mediaTime, frame.mediaTime);
-        endTime = Math.max(endTime ?? getFrameEndTime(frame), getFrameEndTime(frame));
+        endTime = Math.max(endTime ?? getFrameEndTime$1(frame), getFrameEndTime$1(frame));
     }
     dataset.startTime = startTime;
     dataset.endTime = endTime;
@@ -1381,10 +1564,10 @@ function createWriteSummary(datasetId, dataset) {
 }
 function getFrameChunkIndexes(frame, chunkDurationSeconds) {
     const startIndex = getChunkIndex(frame.mediaTime, chunkDurationSeconds);
-    const endIndex = Math.max(startIndex, Math.ceil(getFrameEndTime(frame) / chunkDurationSeconds) - 1);
+    const endIndex = Math.max(startIndex, Math.ceil(getFrameEndTime$1(frame) / chunkDurationSeconds) - 1);
     return Array.from({ length: endIndex - startIndex + 1 }, (_, offset) => startIndex + offset);
 }
-function getFrameEndTime(frame) {
+function getFrameEndTime$1(frame) {
     return frame.endTime ?? frame.mediaTime;
 }
 function getChunkIndex(mediaTime, chunkDurationSeconds) {
@@ -1395,11 +1578,87 @@ function getDetectionFrameDedupeKey(frame) {
         ? `time:${frame.mediaTime}`
         : `index:${frame.frameIndex}`;
 }
+/**
+ * Rejects a retention floor that could not describe a real media time.
+ *
+ * Pruning mutates retained history in place, and `NaN` compares false against
+ * every retained frame, so an unvalidated floor would silently erase a dataset
+ * instead of evicting a bounded range.
+ */
+function assertRetentionFloor(startTime) {
+    if (!Number.isFinite(startTime) || startTime < 0) {
+        throw new RangeError("pruneFrames requires a finite, non-negative startTime.");
+    }
+}
+
+/**
+ * Wraps a detection source so every loaded frame that declares a source
+ * coordinate space is projected into the target space.
+ *
+ * The target is resolved per load because media dimensions are only known once
+ * the media has opened, while sources are composed before that. Frames without
+ * `coordinateSpace`, and loads made before a target exists, pass through by
+ * reference, so a producer already emitting media-pixel geometry pays nothing.
+ *
+ * The target is also handed to the wrapped source through
+ * `DetectionFrameLoadOptions`. A source that flattens child frames, such as a
+ * composite source, needs it to project each child while that child's own
+ * `coordinateSpace` is still attached; projecting the flattened result again
+ * here is then a no-op.
+ *
+ * Optional source hooks are forwarded only when the wrapped source implements
+ * them, so capability detection keeps working through the wrapper.
+ */
+function createProjectedDetectionFrameSource(source, resolveTarget) {
+    const { getAvailableRanges, getChangesSince, getVersion, waitForRange } = source;
+    return {
+        async loadFrames(startTime, endTime, options) {
+            const target = resolveTarget();
+            const frames = await source.loadFrames(startTime, endTime, {
+                ...options,
+                ...(target ? { coordinateSpace: target } : {}),
+            });
+            return target ? projectDetectionFrames(frames, target) : frames;
+        },
+        ...(waitForRange
+            ? {
+                waitForRange: (range) => waitForRange.call(source, range),
+            }
+            : {}),
+        ...(getAvailableRanges
+            ? { getAvailableRanges: () => getAvailableRanges.call(source) }
+            : {}),
+        ...(getVersion
+            ? {
+                getVersion: (range) => getVersion.call(source, range),
+            }
+            : {}),
+        ...(getChangesSince
+            ? {
+                getChangesSince: (version, ranges) => getChangesSince.call(source, version, ranges),
+            }
+            : {}),
+        ...(source.destroy ? { destroy: () => source.destroy?.() } : {}),
+    };
+}
 
 const RANGE_EPSILON_SECONDS = 1e-6;
 const MAX_CHANGED_RANGE_JOURNAL_LENGTH = 512;
+const DEFAULT_LIVE_HOLD_SECONDS = 60;
+const NO_COVERAGE_INVALIDATION = { ranges: [] };
 function createWritableDetectionFrameSource(options) {
+    const liveHoldSeconds = resolveLiveHoldSeconds(options.live?.holdSeconds);
     let summary = null;
+    let latestFrame = null;
+    let heldLiveFrame = null;
+    // Newest live `mediaTime` accepted so far. It survives retention so a late
+    // result cannot reopen coverage the source already moved past.
+    let liveFrontierTime = null;
+    // Newest media time actually covered by producer-declared data. Live frames
+    // are written with a synthetic hold end, so the summary end time cannot be
+    // used to place the retention window without pushing it into the future.
+    let coverageFrontierTime = null;
+    let writeQueue = Promise.resolve();
     let version = 0;
     let allRangeVersion = 0;
     let journalFloorVersion = 0;
@@ -1412,13 +1671,25 @@ function createWritableDetectionFrameSource(options) {
         datasetId: options.datasetId,
         frames,
     });
-    const recordRangeWrite = (nextSummary, changedSourceRanges) => {
+    const recordRangeWrite = (nextSummary, changedSourceRanges, invalidation, prunedRange) => {
         summary = nextSummary;
         version += 1;
         for (const changedRange of changedSourceRanges) {
             changedRanges.push({ ...changedRange, version });
             recordAvailableRange(changedRange, availableRanges);
         }
+        for (const invalidatedRange of invalidation.ranges) {
+            // Coverage a write took away is journaled but never made available: a
+            // consumer parked there has to redraw, and nothing new can be loaded.
+            changedRanges.push({ ...invalidatedRange, version });
+        }
+        if (prunedRange) {
+            // Evicting old history is a change to that range only. Recording it
+            // alongside the append keeps a buffered timeline patching two small
+            // ranges instead of invalidating and rebuilding everything it retains.
+            changedRanges.push({ ...prunedRange, version });
+            dropAvailableRangesBefore(prunedRange.endTime, availableRanges);
+        }
         compactChangedRangeJournal();
         resolveCoveredWaiters();
         return nextSummary;
@@ -1443,38 +1714,113 @@ function createWritableDetectionFrameSource(options) {
         datasetId: options.datasetId,
         async appendFrames(frames) {
             assertActive();
-            const nextSummary = await options.store.appendFrames(writeOptions(frames));
+            return enqueueWrite(async () => {
+                const nextSummary = await options.store.appendFrames(writeOptions(frames));
+                assertActive();
+                const changedSourceRanges = getDetectionFrameRanges(frames);
+                const invalidation = getInvalidatedCoverage(frames, changedSourceRanges);
+                recordLatestFrame(frames);
+                recordCoverageFrontierFromFrames(frames);
+                return retainAndRecord(nextSummary, changedSourceRanges, invalidation);
+            });
+        },
+        async appendLiveFrame(frame) {
             assertActive();
-            const changedSourceRanges = getDetectionFrameRanges(frames);
-            const retainedSummary = await applyRetention(nextSummary);
+            return enqueueWrite(async () => {
+                if (isStaleLiveFrame(frame)) {
+                    // A result older than the live frontier no longer describes what is
+                    // on screen. Writing it would reopen coverage the source already
+                    // closed, so the newest causal frame simply wins.
+                    return summary ? { ...summary } : createEmptyWriteSummary();
+                }
+                const framesToWrite = createLiveFrameWrite(frame);
+                const nextSummary = await options.store.appendFrames(writeOptions(framesToWrite));
+                assertActive();
+                const changedSourceRanges = getDetectionFrameRanges(framesToWrite);
+                const invalidation = getInvalidatedCoverage(framesToWrite, changedSourceRanges);
+                heldLiveFrame = framesToWrite.at(-1) ?? null;
+                liveFrontierTime = Math.max(liveFrontierTime ?? frame.mediaTime, frame.mediaTime);
+                recordLatestFrame(framesToWrite);
+                // The hold end is a placeholder for "still current", not covered data.
+                recordCoverageFrontier(getFrameEndTime(frame));
+                return retainAndRecord(nextSummary, changedSourceRanges, invalidation);
+            });
+        },
+        async finalizeCoverage(endTime) {
             assertActive();
-            if (retainedSummary !== nextSummary) {
-                return recordAllRangesWrite(retainedSummary);
-            }
-            if (changedSourceRanges.length === 0) {
-                summary = nextSummary;
-                return nextSummary;
+            if (!Number.isFinite(endTime)) {
+                throw new RangeError("finalizeCoverage requires a finite endTime.");
             }
-            return recordRangeWrite(nextSummary, changedSourceRanges);
+            return enqueueWrite(async () => {
+                const frameToFinalize = latestFrame;
+                if (!frameToFinalize ||
+                    // A frame that starts at or after the end of media cannot describe a
+                    // non-empty terminal interval.
+                    frameToFinalize.mediaTime >= endTime ||
+                    getFrameEndTime(frameToFinalize) === endTime) {
+                    return summary ? { ...summary } : null;
+                }
+                const previousEndTime = getFrameEndTime(frameToFinalize);
+                const finalizedFrame = { ...frameToFinalize, endTime };
+                const nextSummary = await options.store.appendFrames(writeOptions([finalizedFrame]));
+                assertActive();
+                const changedSourceRanges = [
+                    {
+                        endTime: Math.max(endTime, previousEndTime),
+                        startTime: frameToFinalize.mediaTime,
+                    },
+                ];
+                const invalidation = getInvalidatedCoverage([finalizedFrame], changedSourceRanges);
+                latestFrame = finalizedFrame;
+                if (heldLiveFrame &&
+                    haveSameDetectionFrameIdentity(heldLiveFrame, finalizedFrame)) {
+                    heldLiveFrame = finalizedFrame;
+                }
+                coverageFrontierTime = endTime;
+                const finalSummary = await retainAndRecord(nextSummary, changedSourceRanges, 
+                // Finalizing usually closes at the end of media, where the tail an
+                // open-ended frame gives up is unreachable. The caller may finalize
+                // earlier, though, so report it rather than assume.
+                invalidation);
+                // Closing a held live frame shortens coverage. Reported availability
+                // has to shrink with it, or a playback gate would still believe the
+                // source covers time past the end of media.
+                clipAvailableRangesAfter(endTime);
+                return finalSummary;
+            });
         },
         async replaceFrames(frames) {
             assertActive();
-            const nextSummary = await options.store.putFrames(writeOptions(frames));
-            assertActive();
-            const retainedSummary = await applyRetention(nextSummary);
-            assertActive();
-            return recordAllRangesWrite(retainedSummary);
+            return enqueueWrite(async () => {
+                const nextSummary = await options.store.putFrames(writeOptions(frames));
+                assertActive();
+                latestFrame = null;
+                heldLiveFrame = null;
+                liveFrontierTime = null;
+                coverageFrontierTime = null;
+                recordLatestFrame(frames);
+                recordCoverageFrontierFromFrames(frames);
+                const retention = await applyRetention(nextSummary);
+                assertActive();
+                return recordAllRangesWrite(retention.kind === "unchanged" ? nextSummary : retention.summary);
+            });
         },
         async clear() {
             assertActive();
-            await options.store.clearDataset(options.datasetId);
-            assertActive();
-            summary = null;
-            version += 1;
-            allRangeVersion = version;
-            journalFloorVersion = version;
-            changedRanges.length = 0;
-            availableRanges.length = 0;
+            await enqueueWrite(async () => {
+                await options.store.clearDataset(options.datasetId);
+                assertActive();
+                summary = null;
+                latestFrame = null;
+                heldLiveFrame = null;
+                liveFrontierTime = null;
+                coverageFrontierTime = null;
+                version += 1;
+                allRangeVersion = version;
+                journalFloorVersion = version;
+                changedRanges.length = 0;
+                availableRanges.length = 0;
+            });
         },
         async loadFrames(startTime, endTime) {
             assertActive();
@@ -1507,14 +1853,10 @@ function createWritableDetectionFrameSource(options) {
             if (!range) {
                 return version;
             }
-            return changedRanges.reduce((rangeVersion, changedRange) => rangesOverlap(range, changedRange)
-                ? Math.max(rangeVersion, changedRange.version)
-                : rangeVersion, Math.max(allRangeVersion, journalFloorVersion));
+            return getRangeVersion(range);
         },
         getChangesSince(previousVersion, ranges) {
-            const relevantVersion = ranges.reduce((rangeVersion, range) => Math.max(rangeVersion, changedRanges.reduce((changedVersion, changedRange) => rangesOverlap(range, changedRange)
-                ? Math.max(changedVersion, changedRange.version)
-                : changedVersion, Math.max(allRangeVersion, journalFloorVersion))), Math.max(allRangeVersion, journalFloorVersion));
+            const relevantVersion = ranges.reduce((rangeVersion, range) => Math.max(rangeVersion, getRangeVersion(range)), getReloadFloorVersion());
             if (relevantVersion <= previousVersion) {
                 return {
                     ranges: [],
@@ -1522,18 +1864,34 @@ function createWritableDetectionFrameSource(options) {
                     version: relevantVersion,
                 };
             }
-            if (previousVersion < allRangeVersion ||
-                previousVersion < journalFloorVersion) {
+            if (previousVersion < getReloadFloorVersion()) {
                 return {
                     ranges: [],
                     requiresReload: true,
                     version: relevantVersion,
                 };
             }
+            // Clipped to the requested ranges: a consumer gets back exactly the part
+            // of the change it asked about, and an unbounded invalidation stays a
+            // bounded, loadable answer.
             const changedSourceRanges = changedRanges
-                .filter((changedRange) => changedRange.version > previousVersion &&
-                ranges.some((range) => rangesOverlap(range, changedRange)))
-                .map(({ endTime, startTime }) => ({ endTime, startTime }));
+                .filter((changedRange) => changedRange.version > previousVersion)
+                .flatMap((changedRange) => ranges
+                .filter((range) => rangesOverlap(range, changedRange))
+                .map((range) => {
+                const startTime = Math.max(range.startTime, changedRange.startTime);
+                const endTime = Math.min(range.endTime, changedRange.endTime);
+                return {
+                    // An unbounded ask against an unbounded invalidation would
+                    // otherwise hand back an infinite range, and a consumer would
+                    // take it straight to `loadFrames`. Nothing past the coverage
+                    // the source knows about can be loaded.
+                    endTime: Number.isFinite(endTime)
+                        ? endTime
+                        : Math.max(startTime, getKnownEndTime()),
+                    startTime,
+                };
+            }));
             return {
                 ranges: mergeRanges(changedSourceRanges),
                 requiresReload: false,
@@ -1557,12 +1915,112 @@ function createWritableDetectionFrameSource(options) {
             throw createDestroyedError();
         }
     }
+    /**
+     * Oldest version the journal can still describe incrementally. Anything
+     * older has to reload, because replacement, clearing, or journal compaction
+     * dropped the intervening changes.
+     */
+    function getReloadFloorVersion() {
+        return Math.max(allRangeVersion, journalFloorVersion);
+    }
+    /**
+     * Latest media time the source can actually serve frames for.
+     */
+    function getKnownEndTime() {
+        return Math.max(coverageFrontierTime ?? 0, summary?.endTime ?? 0);
+    }
+    function getRangeVersion(range) {
+        return changedRanges.reduce((rangeVersion, changedRange) => rangesOverlap(range, changedRange)
+            ? Math.max(rangeVersion, changedRange.version)
+            : rangeVersion, getReloadFloorVersion());
+    }
+    /**
+     * Runs mutating writes one at a time.
+     *
+     * Every write reads the held live frame, the latest frame, and the coverage
+     * frontier before it awaits storage. Without serialization two concurrent
+     * live appends would both observe the pre-write state and both stay open,
+     * which is exactly the stale overlay live semantics exist to prevent.
+     */
+    function enqueueWrite(run) {
+        const result = writeQueue.then(() => {
+            assertActive();
+            return run();
+        });
+        writeQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    function isStaleLiveFrame(frame) {
+        if (liveFrontierTime === null || frame.mediaTime > liveFrontierTime) {
+            return false;
+        }
+        // A frame at the frontier that shares the held frame's identity is a
+        // revision of the current result, not a late duplicate of an older one.
+        return !(heldLiveFrame && haveSameDetectionFrameIdentity(heldLiveFrame, frame));
+    }
+    function recordCoverageFrontier(endTime) {
+        coverageFrontierTime =
+            coverageFrontierTime === null
+                ? endTime
+                : Math.max(coverageFrontierTime, endTime);
+    }
+    function recordCoverageFrontierFromFrames(frames) {
+        for (const frame of frames) {
+            recordCoverageFrontier(getFrameEndTime(frame));
+        }
+    }
+    function clipAvailableRangesAfter(endTime) {
+        let writeIndex = 0;
+        for (const range of availableRanges) {
+            if (range.startTime >= endTime) {
+                continue;
+            }
+            availableRanges[writeIndex] = {
+                endTime: Math.min(range.endTime, endTime),
+                startTime: range.startTime,
+            };
+            writeIndex += 1;
+        }
+        availableRanges.length = writeIndex;
+    }
+    function createEmptyWriteSummary() {
+        return {
+            chunkCount: 0,
+            chunkDurationSeconds: options.chunkDurationSeconds ?? 1,
+            datasetId: options.datasetId,
+            detectionCount: 0,
+            endTime: null,
+            frameCount: 0,
+            startTime: null,
+        };
+    }
+    /**
+     * Applies retention and records the result as an incremental change when the
+     * store can prune in place, or as a full rewrite when it cannot.
+     */
+    async function retainAndRecord(nextSummary, changedSourceRanges, invalidation = NO_COVERAGE_INVALIDATION) {
+        const retention = await applyRetention(nextSummary);
+        assertActive();
+        if (retention.kind === "rewritten") {
+            return recordAllRangesWrite(retention.summary);
+        }
+        if (retention.kind === "unchanged") {
+            if (changedSourceRanges.length === 0 &&
+                invalidation.ranges.length === 0) {
+                summary = nextSummary;
+                return nextSummary;
+            }
+            return recordRangeWrite(nextSummary, changedSourceRanges, invalidation);
+        }
+        forgetFramesBefore(retention.prunedRange.endTime);
+        return recordRangeWrite(retention.summary, changedSourceRanges, invalidation, retention.prunedRange);
+    }
     async function applyRetention(nextSummary) {
         const retention = options.retention;
         if (retention === undefined ||
             !shouldApplyWindowRetention(retention) ||
             nextSummary.endTime === null) {
-            return nextSummary;
+            return { kind: "unchanged" };
         }
         const retentionWindowSeconds = retention.windowSeconds;
         if (retentionWindowSeconds === undefined ||
@@ -1570,17 +2028,119 @@ function createWritableDetectionFrameSource(options) {
             retentionWindowSeconds <= 0) {
             throw new Error("retention.windowSeconds must be greater than 0.");
         }
-        const retentionStartTime = Math.max(0, nextSummary.endTime - retentionWindowSeconds);
+        // Place the window against real producer coverage. A live frame held open
+        // for `holdSeconds` reports a summary end far in the future, and anchoring
+        // eviction there would evict everything the producer just wrote.
+        const retentionStartTime = Math.max(0, Math.min(coverageFrontierTime ?? nextSummary.endTime, nextSummary.endTime) - retentionWindowSeconds);
         if (nextSummary.startTime !== null &&
             nextSummary.startTime + RANGE_EPSILON_SECONDS >= retentionStartTime) {
-            return nextSummary;
+            return { kind: "unchanged" };
         }
+        if (options.store.pruneFrames) {
+            return {
+                kind: "pruned",
+                prunedRange: {
+                    endTime: retentionStartTime,
+                    startTime: nextSummary.startTime ?? 0,
+                },
+                summary: await options.store.pruneFrames({
+                    datasetId: options.datasetId,
+                    startTime: retentionStartTime,
+                }),
+            };
+        }
+        // Stores without in-place pruning still get a correct retention window,
+        // at the cost of reloading and rewriting everything they keep.
         const retainedFrames = await options.store.loadFrames({
             datasetId: options.datasetId,
             endTime: nextSummary.endTime,
             startTime: retentionStartTime,
         });
-        return options.store.putFrames(writeOptions(retainedFrames));
+        return {
+            kind: "rewritten",
+            summary: await options.store.putFrames(writeOptions(retainedFrames)),
+        };
+    }
+    /**
+     * Builds the one or two frames a live append writes: the newest frame held
+     * open, plus the previously held frame closed where the newest begins.
+     */
+    function createLiveFrameWrite(frame) {
+        const openFrame = {
+            ...frame,
+            endTime: Math.max(frame.endTime ?? frame.mediaTime, frame.mediaTime + liveHoldSeconds),
+        };
+        const heldFrame = heldLiveFrame;
+        // Stale results are rejected before this point, so a held frame that is
+        // neither the same frame nor already closed always ends strictly later.
+        if (!heldFrame ||
+            haveSameDetectionFrameIdentity(heldFrame, openFrame) ||
+            getFrameEndTime(heldFrame) <= frame.mediaTime) {
+            return [openFrame];
+        }
+        return [{ ...heldFrame, endTime: frame.mediaTime }, openFrame];
+    }
+    function recordLatestFrame(frames) {
+        for (const frame of frames) {
+            if (!latestFrame ||
+                compareDetectionFrames(frame, latestFrame) > 0 ||
+                // A write that shares the tracked frame's identity replaces its stored
+                // record. Keeping the superseded contents here would let a later
+                // `finalizeCoverage` write them back over the revision.
+                haveSameDetectionFrameIdentity(frame, latestFrame)) {
+                latestFrame = frame;
+            }
+        }
+    }
+    /**
+     * Coverage a write takes away from a frame the source already wrote.
+     *
+     * The journal describes a write by the interval it covers, which is enough
+     * while writes only add. Rewriting a frame with a shorter interval, or at a
+     * different time, instead stops covering times the new interval never
+     * mentions, and a consumer parked in one of them would keep showing a frame
+     * the source no longer selects.
+     *
+     * A frame without an `endTime` was selected with no upper bound, so what it
+     * gives up is genuinely unbounded and is journaled that way. The journal
+     * stays range-scoped either way: a consumer asking about times the write
+     * never touched still hears that nothing changed.
+     */
+    function getInvalidatedCoverage(frames, coveredRanges) {
+        const invalidatedRanges = [];
+        for (const frame of frames) {
+            for (const trackedFrame of [latestFrame, heldLiveFrame]) {
+                if (!trackedFrame ||
+                    !haveSameDetectionFrameIdentity(trackedFrame, frame)) {
+                    continue;
+                }
+                const previousRange = {
+                    endTime: trackedFrame.endTime ?? Number.POSITIVE_INFINITY,
+                    startTime: trackedFrame.mediaTime,
+                };
+                const nextEndTime = frame.endTime ?? Number.POSITIVE_INFINITY;
+                if (trackedFrame.mediaTime >= frame.mediaTime &&
+                    previousRange.endTime <= nextEndTime) {
+                    continue;
+                }
+                // A live append closes the held frame and reopens it further out in the
+                // same write, so the write's own range already describes the tail. Only
+                // coverage nothing else reported is worth a second journal entry.
+                if (isRangeCovered(previousRange, coveredRanges)) {
+                    continue;
+                }
+                invalidatedRanges.push(previousRange);
+            }
+        }
+        return { ranges: mergeRanges(invalidatedRanges) };
+    }
+    function forgetFramesBefore(startTime) {
+        if (latestFrame && getFrameEndTime(latestFrame) < startTime) {
+            latestFrame = null;
+        }
+        if (heldLiveFrame && getFrameEndTime(heldLiveFrame) < startTime) {
+            heldLiveFrame = null;
+        }
     }
     function resolveCoveredWaiters() {
         for (let index = waiters.length - 1; index >= 0; index -= 1) {
@@ -1604,6 +2164,43 @@ function createWritableDetectionFrameSource(options) {
 function createDestroyedError() {
     return new Error("Detection frame source has been destroyed.");
 }
+function resolveLiveHoldSeconds(holdSeconds) {
+    if (holdSeconds === undefined) {
+        return DEFAULT_LIVE_HOLD_SECONDS;
+    }
+    if (!Number.isFinite(holdSeconds) || holdSeconds <= 0) {
+        throw new RangeError("live.holdSeconds must be greater than 0.");
+    }
+    return holdSeconds;
+}
+function getFrameEndTime(frame) {
+    return frame.endTime ?? frame.mediaTime;
+}
+function haveSameDetectionFrameIdentity(left, right) {
+    return left.frameIndex === undefined || right.frameIndex === undefined
+        ? left.frameIndex === right.frameIndex && left.mediaTime === right.mediaTime
+        : left.frameIndex === right.frameIndex;
+}
+function compareDetectionFrames(left, right) {
+    if (left.mediaTime !== right.mediaTime) {
+        return left.mediaTime - right.mediaTime;
+    }
+    return (left.frameIndex ?? 0) - (right.frameIndex ?? 0);
+}
+function dropAvailableRangesBefore(startTime, availableRanges) {
+    let writeIndex = 0;
+    for (const range of availableRanges) {
+        if (range.endTime <= startTime) {
+            continue;
+        }
+        availableRanges[writeIndex] = {
+            endTime: range.endTime,
+            startTime: Math.max(range.startTime, startTime),
+        };
+        writeIndex += 1;
+    }
+    availableRanges.length = writeIndex;
+}
 function shouldApplyWindowRetention(retention) {
     return (retention?.mode === DetectionFrameRetentionMode.PersistWindow ||
         retention?.mode === DetectionFrameRetentionMode.MemoryOnly);
@@ -1657,42 +2254,1407 @@ 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 [];
+    }
+    const rowCount = scores.length;
+    const columnCount = scores[0].length;
+    const transposed = rowCount > columnCount;
+    const costs = transposed
+        ? Array.from({ length: columnCount }, (_, row) => Array.from({ length: rowCount }, (_, column) => 1 - scores[column][row]))
+        : scores.map((row) => row.map((score) => 1 - score));
+    const rows = costs.length;
+    const columns = costs[0].length;
+    const u = new Array(rows + 1).fill(0);
+    const v = new Array(columns + 1).fill(0);
+    const p = new Array(columns + 1).fill(0);
+    const way = new Array(columns + 1).fill(0);
+    for (let row = 1; row <= rows; row += 1) {
+        p[0] = row;
+        let column0 = 0;
+        const minValue = new Array(columns + 1).fill(Number.POSITIVE_INFINITY);
+        const used = new Array(columns + 1).fill(false);
+        do {
+            used[column0] = true;
+            const row0 = p[column0];
+            let delta = Number.POSITIVE_INFINITY;
+            let column1 = 0;
+            for (let column = 1; column <= columns; column += 1) {
+                if (used[column])
+                    continue;
+                const current = costs[row0 - 1][column - 1] - u[row0] - v[column];
+                if (current < minValue[column]) {
+                    minValue[column] = current;
+                    way[column] = column0;
+                }
+                if (minValue[column] < delta) {
+                    delta = minValue[column];
+                    column1 = column;
+                }
+            }
+            for (let column = 0; column <= columns; column += 1) {
+                if (used[column]) {
+                    u[p[column]] += delta;
+                    v[column] -= delta;
+                }
+                else {
+                    minValue[column] -= delta;
+                }
+            }
+            column0 = column1;
+        } while (p[column0] !== 0);
+        do {
+            const column1 = way[column0];
+            p[column0] = p[column1];
+            column0 = column1;
+        } while (column0 !== 0);
+    }
+    const assignments = [];
+    for (let column = 1; column <= columns; column += 1) {
+        if (p[column] === 0)
+            continue;
+        const row = p[column] - 1;
+        assignments.push(transposed ? [column - 1, row] : [row, column - 1]);
+    }
+    return assignments;
+}
+function rectToXyxy(rect) {
+    return [
+        rect.x - rect.width / 2,
+        rect.y - rect.height / 2,
+        rect.x + rect.width / 2,
+        rect.y + rect.height / 2,
+    ];
+}
+function stateToRect(state) {
+    // The Python XYXY estimator intentionally leaves corner velocities
+    // unconstrained. Normalize only at the browser Rect boundary so a crossing
+    // prediction cannot violate the positive-width/height storage contract.
+    const x1 = Math.min(state[0][0], state[2][0]);
+    const y1 = Math.min(state[1][0], state[3][0]);
+    const x2 = Math.max(state[0][0], state[2][0]);
+    const y2 = Math.max(state[1][0], state[3][0]);
+    return {
+        height: Math.max(Number.EPSILON, y2 - y1),
+        width: Math.max(Number.EPSILON, x2 - x1),
+        x: (x1 + x2) / 2,
+        y: (y1 + y2) / 2,
+    };
+}
+function createProcessNoise(frameStep, frameRate) {
+    if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {
+        return scale(identity(8), 0.01);
+    }
+    const result = Array.from({ length: 8 }, () => new Array(8).fill(0));
+    const dt2 = frameStep * frameStep;
+    const dt3 = dt2 * frameStep;
+    const dt4 = dt2 * dt2;
+    for (let index = 0; index < 4; index += 1) {
+        const velocityIndex = index + 4;
+        result[index][index] = (0.01 * dt4) / 4;
+        result[index][velocityIndex] = (0.01 * dt3) / 2;
+        result[velocityIndex][index] = (0.01 * dt3) / 2;
+        result[velocityIndex][velocityIndex] = 0.01 * dt2;
+    }
+    return result;
+}
+function intersectionOverUnion(left, right) {
+    const leftX = left.x - left.width / 2;
+    const leftY = left.y - left.height / 2;
+    const rightX = right.x - right.width / 2;
+    const rightY = right.y - right.height / 2;
+    const intersectionWidth = Math.max(0, Math.min(leftX + left.width, rightX + right.width) -
+        Math.max(leftX, rightX));
+    const intersectionHeight = Math.max(0, Math.min(leftY + left.height, rightY + right.height) -
+        Math.max(leftY, rightY));
+    const intersection = intersectionWidth * intersectionHeight;
+    const union = left.width * left.height + right.width * right.height - intersection;
+    return union <= 0 ? 0 : intersection / union;
+}
+function resolveFrameStep(current, previous) {
+    if (current === undefined || previous === undefined)
+        return 1;
+    return Math.max(1, current - previous);
+}
+function normalizePositiveInteger$1(value, label) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return value;
+}
+function normalizeNonNegativeInteger$1(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer.`);
+    }
+    return value;
+}
+function normalizeUnitInterval$1(value, label) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`${label} must be between 0 and 1.`);
+    }
+}
+function identity(size) {
+    return Array.from({ length: size }, (_, row) => Array.from({ length: size }, (_, column) => (row === column ? 1 : 0)));
+}
+function scale(matrix, factor) {
+    return matrix.map((row) => row.map((value) => value * factor));
+}
+function transpose(matrix) {
+    return matrix[0].map((_, column) => matrix.map((row) => row[column]));
+}
+function add(left, right) {
+    return left.map((row, rowIndex) => row.map((value, columnIndex) => value + right[rowIndex][columnIndex]));
+}
+function subtract(left, right) {
+    return left.map((row, rowIndex) => row.map((value, columnIndex) => value - right[rowIndex][columnIndex]));
+}
+function multiply(left, right) {
+    return left.map((row) => right[0].map((_, column) => row.reduce((sum, value, index) => sum + value * right[index][column], 0)));
+}
+function inverse(matrix) {
+    const size = matrix.length;
+    const augmented = matrix.map((row, index) => [
+        ...row,
+        ...identity(size)[index],
+    ]);
+    for (let column = 0; column < size; column += 1) {
+        let pivot = column;
+        for (let row = column + 1; row < size; row += 1) {
+            if (Math.abs(augmented[row][column]) >
+                Math.abs(augmented[pivot][column])) {
+                pivot = row;
+            }
+        }
+        if (Math.abs(augmented[pivot][column]) < 1e-12) {
+            throw new Error("SORT Kalman covariance is singular.");
+        }
+        [augmented[column], augmented[pivot]] = [
+            augmented[pivot],
+            augmented[column],
+        ];
+        const divisor = augmented[column][column];
+        augmented[column] = augmented[column].map((value) => value / divisor);
+        for (let row = 0; row < size; row += 1) {
+            if (row === column)
+                continue;
+            const factor = augmented[row][column];
+            augmented[row] = augmented[row].map((value, index) => value - factor * augmented[column][index]);
+        }
+    }
+    return augmented.map((row) => row.slice(size));
+}
+
+/**
+ * Creates one stateful ByteTrack tracker for a single ordered media sequence.
+ *
+ * Defaults and two-stage association mirror roboflow/trackers ByteTrack at
+ * source commit 60b21c8a48676784085fbee455559f16b75a7c9a.
+ * Motion predictions remain internal; only observed detections receive IDs.
+ */
+function createByteTrackTracker$1(options = {}) {
+    const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, "lostTrackBuffer");
+    const frameRate = options.frameRate ?? 30;
+    const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;
+    const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, "minimumConsecutiveFrames");
+    const minimumIouThreshold = options.minimumIouThreshold ?? 0.1;
+    const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;
+    if (!Number.isFinite(frameRate) || frameRate <= 0) {
+        throw new Error("frameRate must be a finite positive value.");
+    }
+    normalizeUnitInterval$1(trackActivationThreshold, "trackActivationThreshold");
+    normalizeUnitInterval$1(minimumIouThreshold, "minimumIouThreshold");
+    normalizeUnitInterval$1(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+    const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;
+    if (!Number.isFinite(scaledLostTrackBuffer)) {
+        throw new Error("Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.");
+    }
+    const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));
+    let tracks = [];
+    let nextTrackerId = 0;
+    let previousFrameIndex;
+    return {
+        reset() {
+            tracks = [];
+            nextTrackerId = 0;
+            previousFrameIndex = undefined;
+        },
+        update(detections, frameIndex) {
+            const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);
+            previousFrameIndex = frameIndex ?? previousFrameIndex;
+            tracks.forEach((track) => track.predict(frameStep, frameRate));
+            const highDetectionIndexes = [];
+            const lowDetectionIndexes = [];
+            detections.forEach((detection, index) => {
+                if ((detection.confidence ?? 1) >= highConfidenceDetectionThreshold) {
+                    highDetectionIndexes.push(index);
+                }
+                else {
+                    lowDetectionIndexes.push(index);
+                }
+            });
+            const assignments = new Map();
+            const firstStage = associate(tracks, detections, highDetectionIndexes, minimumIouThreshold);
+            for (const match of firstStage.matches) {
+                updateMatchedTrack(tracks[match.trackIndex], detections[match.detectionIndex], assignments);
+            }
+            const remainingTracks = firstStage.unmatchedTrackIndexes.map((index) => tracks[index]);
+            const secondStage = associate(remainingTracks, detections, lowDetectionIndexes, minimumIouThreshold);
+            for (const match of secondStage.matches) {
+                updateMatchedTrack(remainingTracks[match.trackIndex], detections[match.detectionIndex], assignments);
+            }
+            // Only unmatched high-confidence observations can start a track.
+            for (const detectionIndex of firstStage.unmatchedDetectionIndexes) {
+                const detection = detections[detectionIndex];
+                if ((detection.confidence ?? 1) >= trackActivationThreshold) {
+                    tracks.push(new KalmanBoxTrack(detection, true));
+                }
+            }
+            // Confirmation is sticky once an ID has been allocated. An unmatched
+            // unconfirmed track is discarded immediately, as in Python ByteTrack.
+            tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&
+                (track.trackerId !== undefined ||
+                    track.successfulUpdates >= minimumConsecutiveFrames ||
+                    track.timeSinceUpdate === 0));
+            return {
+                activeTrackCount: tracks.length,
+                assignments: detections.flatMap((detection) => {
+                    const trackerId = assignments.get(detection.detectionIndex);
+                    return trackerId === undefined
+                        ? []
+                        : [{ detectionIndex: detection.detectionIndex, trackerId }];
+                }),
+                confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,
+            };
+        },
+    };
+    function updateMatchedTrack(track, detection, assignments) {
+        track.update(detection);
+        if (track.trackerId === undefined &&
+            track.successfulUpdates >= minimumConsecutiveFrames) {
+            track.trackerId = nextTrackerId;
+            nextTrackerId += 1;
+        }
+        if (track.trackerId !== undefined) {
+            assignments.set(detection.detectionIndex, track.trackerId);
+        }
+    }
+}
+function associate(tracks, detections, detectionIndexes, minimumIouThreshold) {
+    if (tracks.length === 0 || detectionIndexes.length === 0) {
+        return {
+            matches: [],
+            unmatchedDetectionIndexes: [...detectionIndexes],
+            unmatchedTrackIndexes: tracks.map((_, index) => index),
+        };
+    }
+    const scores = tracks.map((track) => {
+        const predictedRect = track.getStateRect();
+        return detectionIndexes.map((detectionIndex) => intersectionOverUnion(predictedRect, detections[detectionIndex].rect));
+    });
+    const matches = [];
+    const matchedTracks = new Set();
+    const matchedDetections = new Set();
+    for (const [trackIndex, localDetectionIndex] of maximizeAssignment(scores)) {
+        if (scores[trackIndex][localDetectionIndex] < minimumIouThreshold) {
+            continue;
+        }
+        const detectionIndex = detectionIndexes[localDetectionIndex];
+        matches.push({ detectionIndex, trackIndex });
+        matchedTracks.add(trackIndex);
+        matchedDetections.add(detectionIndex);
+    }
+    matches.sort((left, right) => left.trackIndex - right.trackIndex);
+    return {
+        matches,
+        unmatchedDetectionIndexes: detectionIndexes.filter((index) => !matchedDetections.has(index)),
+        unmatchedTrackIndexes: tracks.flatMap((_, index) => matchedTracks.has(index) ? [] : [index]),
+    };
+}
+
+function associateTrackingScores(scores, trackCount, detectionCount, minimumScore, acceptanceScores = scores) {
+    const matches = [];
+    const matchedTracks = new Set();
+    const matchedDetections = new Set();
+    for (const [trackIndex, detectionIndex] of maximizeAssignment(scores)) {
+        if (acceptanceScores[trackIndex][detectionIndex] < minimumScore)
+            continue;
+        matches.push({ detectionIndex, trackIndex });
+        matchedTracks.add(trackIndex);
+        matchedDetections.add(detectionIndex);
+    }
+    matches.sort((left, right) => left.trackIndex - right.trackIndex);
+    return {
+        matches,
+        unmatchedDetectionIndexes: Array.from({ length: detectionCount }, (_, index) => index).filter((index) => !matchedDetections.has(index)),
+        unmatchedTrackIndexes: Array.from({ length: trackCount }, (_, index) => index).filter((index) => !matchedTracks.has(index)),
+    };
+}
+function pairwiseIou(tracks, detections, bufferRatio = 0) {
+    return tracks.map((track) => detections.map((detection) => bufferedIntersectionOverUnion(track, detection, bufferRatio)));
+}
+function bufferedIntersectionOverUnion(left, right, bufferRatio) {
+    const leftWidth = left.width * (1 + 2 * bufferRatio);
+    const leftHeight = left.height * (1 + 2 * bufferRatio);
+    const rightWidth = right.width * (1 + 2 * bufferRatio);
+    const rightHeight = right.height * (1 + 2 * bufferRatio);
+    const leftX = left.x - leftWidth / 2;
+    const leftY = left.y - leftHeight / 2;
+    const rightX = right.x - rightWidth / 2;
+    const rightY = right.y - rightHeight / 2;
+    const intersectionWidth = Math.max(0, Math.min(leftX + leftWidth, rightX + rightWidth) - Math.max(leftX, rightX));
+    const intersectionHeight = Math.max(0, Math.min(leftY + leftHeight, rightY + rightHeight) -
+        Math.max(leftY, rightY));
+    const intersection = intersectionWidth * intersectionHeight;
+    const union = leftWidth * leftHeight + rightWidth * rightHeight - intersection;
+    return union <= 0 ? 0 : intersection / union;
+}
+
+/**
+ * Kalman state estimator shared by the browser C-BIoU and OC-SORT ports.
+ * Its layouts, covariance update, and gap-scaled constant-velocity model
+ * mirror roboflow/trackers at 60b21c8.
+ */
+class TrackingKalmanEstimator {
+    representation;
+    dimension;
+    measurementDimension = 4;
+    covariance;
+    measurementNoise = identity(4);
+    processNoise;
+    state;
+    baselineProcessNoise;
+    positionIndexes;
+    velocityIndexes;
+    constructor(initialRect, representation) {
+        this.representation = representation;
+        const measurement = rectToMeasurement(initialRect, representation);
+        this.dimension = representation === "xcycsr" ? 7 : 8;
+        this.positionIndexes =
+            representation === "xcycsr" ? [0, 1, 2] : [0, 1, 2, 3];
+        this.velocityIndexes =
+            representation === "xcycsr" ? [4, 5, 6] : [4, 5, 6, 7];
+        this.state = Array.from({ length: this.dimension }, (_, index) => [
+            measurement[index] ?? 0,
+        ]);
+        this.covariance = identity(this.dimension);
+        this.processNoise = identity(this.dimension);
+        this.baselineProcessNoise = identity(this.dimension);
+    }
+    predict(frameStep, frameRate) {
+        if (this.representation === "xcycsr" &&
+            this.state[2][0] + frameStep * this.state[6][0] <= 0) {
+            this.state[6][0] = 0;
+        }
+        const transition = identity(this.dimension);
+        this.positionIndexes.forEach((positionIndex, index) => {
+            transition[positionIndex][this.velocityIndexes[index]] = frameStep;
+        });
+        this.processNoise = this.createProcessNoise(frameStep, frameRate);
+        this.state = multiply(transition, this.state);
+        this.covariance = add(multiply(multiply(transition, this.covariance), transpose(transition)), this.processNoise);
+    }
+    update(rect) {
+        this.updateMeasurement(rectToMeasurement(rect, this.representation));
+    }
+    updateMeasurement(measurement) {
+        const observation = Array.from({ length: 4 }, (_, row) => Array.from({ length: this.dimension }, (_, column) => row === column ? 1 : 0));
+        const measurementColumn = measurement.map((value) => [value]);
+        const innovation = subtract(measurementColumn, multiply(observation, this.state));
+        const covarianceObservationTranspose = multiply(this.covariance, transpose(observation));
+        const innovationCovariance = add(multiply(observation, covarianceObservationTranspose), this.measurementNoise);
+        const gain = multiply(covarianceObservationTranspose, inverse(innovationCovariance));
+        this.state = add(this.state, multiply(gain, innovation));
+        const identityMinusGainObservation = subtract(identity(this.dimension), multiply(gain, observation));
+        this.covariance = add(multiply(multiply(identityMinusGainObservation, this.covariance), transpose(identityMinusGainObservation)), multiply(multiply(gain, this.measurementNoise), transpose(gain)));
+    }
+    getRect() {
+        return measurementToRect(this.state.slice(0, 4).map((row) => row[0]), this.representation);
+    }
+    setCovariances(options) {
+        if (options.covariance)
+            this.covariance = clone(options.covariance);
+        if (options.measurementNoise) {
+            this.measurementNoise = clone(options.measurementNoise);
+        }
+        if (options.processNoise) {
+            this.processNoise = clone(options.processNoise);
+            this.baselineProcessNoise = clone(options.processNoise);
+        }
+    }
+    snapshot() {
+        return {
+            covariance: clone(this.covariance),
+            measurementNoise: clone(this.measurementNoise),
+            processNoise: clone(this.processNoise),
+            state: clone(this.state),
+        };
+    }
+    restore(snapshot) {
+        this.covariance = clone(snapshot.covariance);
+        this.measurementNoise = clone(snapshot.measurementNoise);
+        this.processNoise = clone(snapshot.processNoise);
+        this.state = clone(snapshot.state);
+    }
+    createProcessNoise(frameStep, frameRate) {
+        if (Math.abs(frameStep - 1) <= 0.004 * frameRate) {
+            return clone(this.baselineProcessNoise);
+        }
+        const result = Array.from({ length: this.dimension }, () => new Array(this.dimension).fill(0));
+        const dt2 = frameStep * frameStep;
+        const dt3 = dt2 * frameStep;
+        const dt4 = dt2 * dt2;
+        const kinematicIndexes = new Set([
+            ...this.positionIndexes,
+            ...this.velocityIndexes,
+        ]);
+        this.positionIndexes.forEach((positionIndex, index) => {
+            const velocityIndex = this.velocityIndexes[index];
+            const accelerationVariance = this.baselineProcessNoise[velocityIndex][velocityIndex];
+            result[positionIndex][positionIndex] = (accelerationVariance * dt4) / 4;
+            result[positionIndex][velocityIndex] = (accelerationVariance * dt3) / 2;
+            result[velocityIndex][positionIndex] = (accelerationVariance * dt3) / 2;
+            result[velocityIndex][velocityIndex] = accelerationVariance * dt2;
+        });
+        for (let index = 0; index < this.dimension; index += 1) {
+            if (!kinematicIndexes.has(index)) {
+                result[index][index] = this.baselineProcessNoise[index][index];
+            }
+        }
+        return result;
+    }
+}
+function rectToMeasurement(rect, representation) {
+    if (representation === "xcycwh") {
+        return [rect.x, rect.y, rect.width, rect.height];
+    }
+    return [
+        rect.x,
+        rect.y,
+        rect.width * rect.height,
+        rect.width / (rect.height + 1e-6),
+    ];
+}
+function measurementToRect(measurement, representation) {
+    const [x, y, third, fourth] = measurement;
+    if (representation === "xcycwh") {
+        return {
+            height: Math.max(1e-3, fourth),
+            width: Math.max(1e-3, third),
+            x,
+            y,
+        };
+    }
+    const width = Math.sqrt(third * fourth);
+    const height = width === 0 ? 0 : third / width;
+    return {
+        height: Math.max(Number.EPSILON, height),
+        width: Math.max(Number.EPSILON, width),
+        x,
+        y,
+    };
+}
+function diagonal(values) {
+    return values.map((value, row) => values.map((_, column) => (row === column ? value : 0)));
+}
+function scaleMatrix(matrix, factor) {
+    return scale(matrix, factor);
+}
+function clone(matrix) {
+    return matrix.map((row) => [...row]);
+}
+
+const MINIMUM_DETECTION_CONFIDENCE = 0.1;
+class CBIoUTrack {
+    trackerId;
+    successfulUpdates = 1;
+    timeSinceUpdate = 0;
+    estimator;
+    constructor(initial) {
+        this.estimator = new TrackingKalmanEstimator(initial.rect, "xcycwh");
+        this.setInitialNoise(initial.rect.width, initial.rect.height);
+    }
+    predict(frameStep, frameRate) {
+        const current = this.estimator.getRect();
+        this.estimator.setCovariances({
+            processNoise: this.buildProcessNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),
+        });
+        this.estimator.predict(frameStep, frameRate);
+        this.clampState();
+        this.timeSinceUpdate += 1;
+    }
+    update(detection) {
+        const current = this.estimator.getRect();
+        this.estimator.setCovariances({
+            measurementNoise: this.buildMeasurementNoise(Math.max(current.width, 1e-3), Math.max(current.height, 1e-3)),
+        });
+        this.estimator.update(detection.rect);
+        this.clampState();
+        this.timeSinceUpdate = 0;
+        this.successfulUpdates += 1;
+    }
+    getRect() {
+        return this.estimator.getRect();
+    }
+    setInitialNoise(width, height) {
+        const sigmaPosition = 0.05;
+        const sigmaVelocity = 0.00625;
+        this.estimator.setCovariances({
+            covariance: diagonal([
+                (2 * sigmaPosition * width) ** 2,
+                (2 * sigmaPosition * height) ** 2,
+                (2 * sigmaPosition * width) ** 2,
+                (2 * sigmaPosition * height) ** 2,
+                (10 * sigmaVelocity * width) ** 2,
+                (10 * sigmaVelocity * height) ** 2,
+                (10 * sigmaVelocity * width) ** 2,
+                (10 * sigmaVelocity * height) ** 2,
+            ]),
+            measurementNoise: this.buildMeasurementNoise(width, height),
+            processNoise: this.buildProcessNoise(width, height),
+        });
+    }
+    buildProcessNoise(width, height) {
+        const sigmaPosition = 0.05;
+        const sigmaVelocity = 0.00625;
+        return diagonal([
+            (sigmaPosition * width) ** 2,
+            (sigmaPosition * height) ** 2,
+            (sigmaPosition * width) ** 2,
+            (sigmaPosition * height) ** 2,
+            (sigmaVelocity * width) ** 2,
+            (sigmaVelocity * height) ** 2,
+            (sigmaVelocity * width) ** 2,
+            (sigmaVelocity * height) ** 2,
+        ]);
+    }
+    buildMeasurementNoise(width, height) {
+        const sigmaMeasurement = 0.05;
+        return diagonal([
+            (sigmaMeasurement * width) ** 2,
+            (sigmaMeasurement * height) ** 2,
+            (sigmaMeasurement * width) ** 2,
+            (sigmaMeasurement * height) ** 2,
+        ]);
+    }
+    clampState() {
+        this.estimator.state[2][0] = Math.max(this.estimator.state[2][0], 1e-3);
+        this.estimator.state[3][0] = Math.max(this.estimator.state[3][0], 1e-3);
+    }
+}
+/** Creates the detection-only C-BIoU implementation from roboflow/trackers. */
+function createCBIoUTracker$1(options = {}) {
+    const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, "lostTrackBuffer");
+    const frameRate = options.frameRate ?? 30;
+    const trackActivationThreshold = options.trackActivationThreshold ?? 0.7;
+    const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 2, "minimumConsecutiveFrames");
+    const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ?? 0.2;
+    const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ?? 0.5;
+    const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ?? 0.3;
+    const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;
+    const instantFirstFrameActivation = options.instantFirstFrameActivation ?? true;
+    const bufferRatioFirst = options.bufferRatioFirst ?? 0.3;
+    const bufferRatioSecond = options.bufferRatioSecond ?? 0.5;
+    if (!Number.isFinite(frameRate) || frameRate <= 0) {
+        throw new Error("frameRate must be a finite positive value.");
+    }
+    normalizeUnitInterval$1(trackActivationThreshold, "trackActivationThreshold");
+    normalizeUnitInterval$1(minimumIouThresholdFirstAssociation, "minimumIouThresholdFirstAssociation");
+    normalizeUnitInterval$1(minimumIouThresholdSecondAssociation, "minimumIouThresholdSecondAssociation");
+    normalizeUnitInterval$1(minimumIouThresholdUnconfirmedAssociation, "minimumIouThresholdUnconfirmedAssociation");
+    normalizeUnitInterval$1(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+    if (!Number.isFinite(bufferRatioFirst) || bufferRatioFirst < 0) {
+        throw new Error("bufferRatioFirst must be a finite non-negative value.");
+    }
+    if (!Number.isFinite(bufferRatioSecond) || bufferRatioSecond < 0) {
+        throw new Error("bufferRatioSecond must be a finite non-negative value.");
+    }
+    const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;
+    if (!Number.isFinite(scaledLostTrackBuffer)) {
+        throw new Error("Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.");
+    }
+    const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));
+    let tracks = [];
+    let nextTrackerId = 0;
+    let frameId = 0;
+    let previousFrameIndex;
+    return {
+        reset() {
+            tracks = [];
+            nextTrackerId = 0;
+            frameId = 0;
+            previousFrameIndex = undefined;
+        },
+        update(detections, frameIndex) {
+            const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);
+            previousFrameIndex = frameIndex ?? previousFrameIndex;
+            frameId += 1;
+            tracks.forEach((track) => track.predict(frameStep, frameRate));
+            const highDetectionIndexes = [];
+            const lowDetectionIndexes = [];
+            detections.forEach((detection, index) => {
+                const confidence = detection.confidence ?? 1;
+                if (confidence >= highConfidenceDetectionThreshold) {
+                    highDetectionIndexes.push(index);
+                }
+                else if (confidence > MINIMUM_DETECTION_CONFIDENCE) {
+                    lowDetectionIndexes.push(index);
+                }
+            });
+            const confirmed = [];
+            const unconfirmed = [];
+            const lost = [];
+            for (const track of tracks) {
+                if (track.timeSinceUpdate > 1)
+                    lost.push(track);
+                else if (track.trackerId !== undefined ||
+                    track.successfulUpdates >= minimumConsecutiveFrames) {
+                    confirmed.push(track);
+                }
+                else
+                    unconfirmed.push(track);
+            }
+            const assignments = new Map();
+            const pool = [...confirmed, ...lost];
+            const highDetections = highDetectionIndexes.map((index) => detections[index]);
+            const firstScores = pairwiseIou(pool.map((track) => track.getRect()), highDetections.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (highDetections[index].confidence ?? 1)));
+            const firstAssociation = associateTrackingScores(firstScores, pool.length, highDetections.length, minimumIouThresholdFirstAssociation);
+            for (const match of firstAssociation.matches) {
+                updateMatchedTrack(pool[match.trackIndex], highDetections[match.detectionIndex], assignments);
+            }
+            const remainingTracked = firstAssociation.unmatchedTrackIndexes
+                .map((index) => pool[index])
+                .filter((track) => track.timeSinceUpdate === 1);
+            const lowDetections = lowDetectionIndexes.map((index) => detections[index]);
+            const secondScores = pairwiseIou(remainingTracked.map((track) => track.getRect()), lowDetections.map((detection) => detection.rect), bufferRatioSecond);
+            const secondAssociation = associateTrackingScores(secondScores, remainingTracked.length, lowDetections.length, minimumIouThresholdSecondAssociation);
+            for (const match of secondAssociation.matches) {
+                updateMatchedTrack(remainingTracked[match.trackIndex], lowDetections[match.detectionIndex], assignments);
+            }
+            let unmatchedHighLocal = [...firstAssociation.unmatchedDetectionIndexes];
+            let unmatchedUnconfirmed = unconfirmed.map((_, index) => index);
+            if (unconfirmed.length > 0 && unmatchedHighLocal.length > 0) {
+                const remainingHigh = unmatchedHighLocal.map((index) => highDetections[index]);
+                const unconfirmedScores = pairwiseIou(unconfirmed.map((track) => track.getRect()), remainingHigh.map((detection) => detection.rect), bufferRatioFirst).map((row) => row.map((score, index) => score * (remainingHigh[index].confidence ?? 1)));
+                const unconfirmedAssociation = associateTrackingScores(unconfirmedScores, unconfirmed.length, remainingHigh.length, minimumIouThresholdUnconfirmedAssociation);
+                unmatchedUnconfirmed = unconfirmedAssociation.unmatchedTrackIndexes;
+                for (const match of unconfirmedAssociation.matches) {
+                    updateMatchedTrack(unconfirmed[match.trackIndex], remainingHigh[match.detectionIndex], assignments);
+                }
+                unmatchedHighLocal =
+                    unconfirmedAssociation.unmatchedDetectionIndexes.map((index) => unmatchedHighLocal[index]);
+            }
+            const unmatchedUnconfirmedTracks = new Set(unmatchedUnconfirmed.map((index) => unconfirmed[index]));
+            tracks = tracks.filter((track) => !unmatchedUnconfirmedTracks.has(track));
+            for (const localIndex of unmatchedHighLocal) {
+                const detection = highDetections[localIndex];
+                if ((detection.confidence ?? 1) < trackActivationThreshold)
+                    continue;
+                const track = new CBIoUTrack(detection);
+                if (frameId === 1 && instantFirstFrameActivation) {
+                    track.trackerId = nextTrackerId++;
+                    assignments.set(detection.detectionIndex, track.trackerId);
+                }
+                tracks.push(track);
+            }
+            tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate &&
+                (track.timeSinceUpdate === 0 ||
+                    track.trackerId !== undefined ||
+                    track.successfulUpdates >= minimumConsecutiveFrames));
+            return createUpdate(detections, assignments, tracks);
+        },
+    };
+    function updateMatchedTrack(track, detection, assignments) {
+        track.update(detection);
+        if (track.trackerId === undefined &&
+            track.successfulUpdates >= minimumConsecutiveFrames) {
+            track.trackerId = nextTrackerId++;
+        }
+        if (track.trackerId !== undefined) {
+            assignments.set(detection.detectionIndex, track.trackerId);
+        }
+    }
+}
+function createUpdate(detections, assignments, tracks) {
+    const resolvedAssignments = detections.flatMap((detection) => {
+        const trackerId = assignments.get(detection.detectionIndex);
+        return trackerId === undefined
+            ? []
+            : [{ detectionIndex: detection.detectionIndex, trackerId }];
+    });
+    return {
+        activeTrackCount: tracks.length,
+        assignments: resolvedAssignments,
+        confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined)
+            .length,
+    };
+}
+
+class OCSortTrack {
+    deltaT;
+    age = 0;
+    lastObservation;
+    trackerId;
+    successfulConsecutiveUpdates = 0;
+    timeSinceUpdate = 0;
+    velocity;
+    frozenState;
+    observed = true;
+    observations = new Map();
+    estimator;
+    constructor(initial, deltaT) {
+        this.deltaT = deltaT;
+        this.lastObservation = initial;
+        this.estimator = new TrackingKalmanEstimator(initial.rect, "xcycsr");
+        this.configureNoise();
+    }
+    predict(frameStep, frameRate) {
+        if (this.observed && this.timeSinceUpdate > 0) {
+            this.frozenState = this.estimator.snapshot();
+            this.observed = false;
+        }
+        this.estimator.predict(frameStep, frameRate);
+        if (this.timeSinceUpdate > 0) {
+            this.successfulConsecutiveUpdates = 0;
+        }
+        this.timeSinceUpdate += 1;
+        this.age += 1;
+    }
+    update(detection, frameStep, frameRate) {
+        const previous = this.getPreviousObservation();
+        if (previous) {
+            this.velocity = computeVelocity(previous, detection);
+        }
+        if (!this.observed && this.frozenState) {
+            this.unfreeze(detection, frameStep, frameRate);
+        }
+        this.estimator.update(detection.rect);
+        this.observed = true;
+        this.timeSinceUpdate = 0;
+        this.successfulConsecutiveUpdates += 1;
+        this.lastObservation = detection;
+        this.observations.set(this.age, detection);
+        const cutoff = this.age - this.deltaT;
+        for (const age of this.observations.keys()) {
+            if (age < cutoff)
+                this.observations.delete(age);
+        }
+    }
+    getRect() {
+        return this.estimator.getRect();
+    }
+    getPreviousObservation() {
+        if (this.observations.size === 0)
+            return undefined;
+        for (let index = 0; index < this.deltaT; index += 1) {
+            const delta = this.deltaT - index;
+            const observation = this.observations.get(this.age - delta);
+            if (observation)
+                return observation;
+        }
+        const latestAge = Math.max(...this.observations.keys());
+        return this.observations.get(latestAge);
+    }
+    configureNoise() {
+        const measurementNoise = identity(4);
+        for (let index = 2; index < 4; index += 1) {
+            measurementNoise[index][index] *= 10;
+        }
+        const covariance = scaleMatrix(identity(7), 10);
+        for (let index = 4; index < 7; index += 1) {
+            covariance[index][index] *= 1000;
+        }
+        const processNoise = identity(7);
+        processNoise[6][6] *= 0.01;
+        for (let index = 4; index < 7; index += 1) {
+            processNoise[index][index] *= 0.01;
+        }
+        this.estimator.setCovariances({
+            covariance,
+            measurementNoise,
+            processNoise,
+        });
+    }
+    unfreeze(detection, frameStep, frameRate) {
+        if (!this.frozenState || this.timeSinceUpdate === 0)
+            return;
+        this.estimator.restore(this.frozenState);
+        const timeGap = this.timeSinceUpdate;
+        const start = rectToMeasurement(this.lastObservation.rect, "xcycsr");
+        const end = rectToMeasurement(detection.rect, "xcycsr");
+        const startWidth = Math.sqrt(start[2] * start[3]);
+        const startHeight = start[3] === 0 ? 0 : Math.sqrt(start[2] / start[3]);
+        const endWidth = Math.sqrt(end[2] * end[3]);
+        const endHeight = end[3] === 0 ? 0 : Math.sqrt(end[2] / end[3]);
+        for (let index = 0; index < timeGap; index += 1) {
+            const progress = (index + 1) / timeGap;
+            const x = start[0] + progress * (end[0] - start[0]);
+            const y = start[1] + progress * (end[1] - start[1]);
+            const width = startWidth + progress * (endWidth - startWidth);
+            const height = startHeight + progress * (endHeight - startHeight);
+            this.estimator.updateMeasurement([x, y, width * height, width / height]);
+            if (index < timeGap - 1) {
+                this.estimator.predict(frameStep, frameRate);
+            }
+        }
+        this.frozenState = undefined;
+    }
+}
+/** Creates the observation-centric SORT implementation from roboflow/trackers. */
+function createOCSortTracker$1(options = {}) {
+    const lostTrackBuffer = normalizeNonNegativeInteger$1(options.lostTrackBuffer ?? 30, "lostTrackBuffer");
+    const frameRate = options.frameRate ?? 30;
+    const minimumConsecutiveFrames = normalizePositiveInteger$1(options.minimumConsecutiveFrames ?? 3, "minimumConsecutiveFrames");
+    const minimumIouThreshold = options.minimumIouThreshold ?? 0.3;
+    const directionConsistencyWeight = options.directionConsistencyWeight ?? 0.2;
+    const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ?? 0.6;
+    const deltaT = normalizePositiveInteger$1(options.deltaT ?? 3, "deltaT");
+    if (!Number.isFinite(frameRate) || frameRate <= 0) {
+        throw new Error("frameRate must be a finite positive value.");
+    }
+    normalizeUnitInterval$1(minimumIouThreshold, "minimumIouThreshold");
+    normalizeUnitInterval$1(directionConsistencyWeight, "directionConsistencyWeight");
+    normalizeUnitInterval$1(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+    const scaledLostTrackBuffer = (frameRate / 30) * lostTrackBuffer;
+    if (!Number.isFinite(scaledLostTrackBuffer)) {
+        throw new Error("Scaled lostTrackBuffer overflows: frameRate / 30 * lostTrackBuffer must be finite.");
+    }
+    const maximumFramesWithoutUpdate = lostTrackBuffer === 0 ? 0 : Math.max(1, Math.ceil(scaledLostTrackBuffer));
+    let tracks = [];
+    let frameCount = 0;
+    let nextTrackerId = 0;
+    let previousFrameIndex;
+    return {
+        reset() {
+            tracks = [];
+            frameCount = 0;
+            nextTrackerId = 0;
+            previousFrameIndex = undefined;
+        },
+        update(detections, frameIndex) {
+            const frameStep = resolveFrameStep(frameIndex, previousFrameIndex);
+            previousFrameIndex = frameIndex ?? previousFrameIndex;
+            // Match roboflow/trackers: an empty stream before any track exists is
+            // not part of OC-SORT's early-sequence activation window.
+            if (tracks.length === 0 && detections.length === 0) {
+                return {
+                    activeTrackCount: 0,
+                    assignments: [],
+                    confirmedTrackCount: 0,
+                };
+            }
+            tracks.forEach((track) => track.predict(frameStep, frameRate));
+            const highDetectionIndexes = detections.flatMap((detection, index) => detection.confidence === undefined ||
+                detection.confidence >= highConfidenceDetectionThreshold
+                ? [index]
+                : []);
+            const highDetections = highDetectionIndexes.map((index) => detections[index]);
+            const iouScores = pairwiseIou(tracks.map((track) => track.getRect()), highDetections.map((detection) => detection.rect));
+            const combinedScores = iouScores.map((row, trackIndex) => row.map((iou, detectionIndex) => {
+                if (directionConsistencyWeight === 0)
+                    return iou;
+                return (iou +
+                    directionConsistencyWeight *
+                        directionConsistency(tracks[trackIndex], highDetections[detectionIndex]) *
+                        (highDetections[detectionIndex].confidence ?? 1));
+            }));
+            const primary = associateTrackingScores(combinedScores, tracks.length, highDetections.length, minimumIouThreshold, iouScores);
+            const assignments = new Map();
+            for (const match of primary.matches) {
+                updateMatchedTrack(tracks[match.trackIndex], highDetections[match.detectionIndex], assignments, frameStep);
+            }
+            let remainingHigh = [...primary.unmatchedDetectionIndexes];
+            if (primary.unmatchedTrackIndexes.length > 0 &&
+                remainingHigh.length > 0) {
+                const unmatchedTracks = primary.unmatchedTrackIndexes.map((index) => tracks[index]);
+                const unmatchedDetections = remainingHigh.map((index) => highDetections[index]);
+                const recoveryScores = pairwiseIou(unmatchedTracks.map((track) => track.lastObservation.rect), unmatchedDetections.map((detection) => detection.rect));
+                const recovery = associateTrackingScores(recoveryScores, unmatchedTracks.length, unmatchedDetections.length, minimumIouThreshold);
+                for (const match of recovery.matches) {
+                    updateMatchedTrack(unmatchedTracks[match.trackIndex], unmatchedDetections[match.detectionIndex], assignments, frameStep);
+                }
+                remainingHigh = recovery.unmatchedDetectionIndexes.map((index) => remainingHigh[index]);
+            }
+            for (const localIndex of remainingHigh) {
+                tracks.push(new OCSortTrack(highDetections[localIndex], deltaT));
+            }
+            tracks = tracks.filter((track) => track.timeSinceUpdate <= maximumFramesWithoutUpdate);
+            frameCount += 1;
+            const resolvedAssignments = detections.flatMap((detection) => {
+                const trackerId = assignments.get(detection.detectionIndex);
+                return trackerId === undefined
+                    ? []
+                    : [{ detectionIndex: detection.detectionIndex, trackerId }];
+            });
+            return {
+                activeTrackCount: tracks.length,
+                assignments: resolvedAssignments,
+                confirmedTrackCount: tracks.filter((track) => track.trackerId !== undefined).length,
+            };
+        },
+    };
+    function updateMatchedTrack(track, detection, assignments, frameStep) {
+        track.update(detection, frameStep, frameRate);
+        const earlySequence = frameCount <= minimumConsecutiveFrames;
+        const shouldEmit = (earlySequence && track.timeSinceUpdate === 0) ||
+            track.successfulConsecutiveUpdates >= minimumConsecutiveFrames;
+        if (shouldEmit) {
+            if (track.trackerId === undefined) {
+                track.trackerId = nextTrackerId++;
+            }
+            assignments.set(detection.detectionIndex, track.trackerId);
+        }
+    }
+}
+function computeVelocity(previous, current) {
+    const deltaX = current.rect.x - previous.rect.x;
+    const deltaY = current.rect.y - previous.rect.y;
+    const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;
+    return { x: deltaX / norm, y: deltaY / norm };
+}
+function directionConsistency(track, detection) {
+    if (!track.velocity)
+        return 0;
+    const reference = track.getPreviousObservation() ?? track.lastObservation;
+    const deltaX = detection.rect.x - reference.rect.x;
+    const deltaY = detection.rect.y - reference.rect.y;
+    const norm = Math.sqrt(deltaX * deltaX + deltaY * deltaY) + 1e-6;
+    const cosine = Math.max(-1, Math.min(1, track.velocity.x * (deltaX / norm) + track.velocity.y * (deltaY / norm)));
+    const angle = Math.acos(cosine);
+    return (Math.PI / 2 - Math.abs(angle)) / Math.PI;
+}
+
+/** Public core facade for the internal tracker engine workspace. */
+function createSortTracker(options = {}) {
+    return createSortTracker$1(options);
+}
+
+/** Public core facade for the internal tracker engine workspace. */
+function createByteTrackTracker(options = {}) {
+    return createByteTrackTracker$1(options);
+}
+
+/** Public core facade for the internal tracker engine workspace. */
+function createCBIoUTracker(options = {}) {
+    return createCBIoUTracker$1(options);
+}
+
+/** Public core facade for the internal tracker engine workspace. */
+function createOCSortTracker(options = {}) {
+    return createOCSortTracker$1(options);
+}
+
+/** Geometry projected into a tracker. The original detection payload is retained. */
+var TrackingGeometry;
+(function (TrackingGeometry) {
+    TrackingGeometry["Box"] = "box";
+    TrackingGeometry["Mask"] = "mask";
+    TrackingGeometry["Keypoints"] = "keypoints";
+})(TrackingGeometry || (TrackingGeometry = {}));
+
+var DetectionMaskPayloadFormat;
+(function (DetectionMaskPayloadFormat) {
+    DetectionMaskPayloadFormat["RawCocoRle"] = "rawCocoRle";
+    DetectionMaskPayloadFormat["DeflatedBase64"] = "deflatedBase64";
+})(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));
+function encodeBinaryMask(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const runs = [];
+    let currentValue = 0;
+    let runLength = 0;
+    for (let x = 0; x < width; x += 1) {
+        for (let y = 0; y < height; y += 1) {
+            const value = data[y * width + x] ? 1 : 0;
+            if (value === currentValue) {
+                runLength += 1;
+            }
+            else {
+                runs.push(runLength);
+                currentValue = value;
+                runLength = 1;
+            }
+        }
+    }
+    runs.push(runLength);
+    return {
+        counts: encodeCompressedRleCounts(runs),
+        encoding: DetectionMaskEncoding.CompressedRle,
+        height,
+        width,
+    };
+}
+/** Encodes a binary mask and derives its bounds in the same raster traversal. */
+function encodeBinaryMaskWithBounds(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const runs = [];
+    let currentValue = 0;
+    let runLength = 0;
+    let minX = width;
+    let minY = height;
+    let maxX = -1;
+    let maxY = -1;
+    for (let x = 0; x < width; x += 1) {
+        for (let y = 0; y < height; y += 1) {
+            const value = data[y * width + x] ? 1 : 0;
+            if (value) {
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+            if (value === currentValue) {
+                runLength += 1;
+            }
+            else {
+                runs.push(runLength);
+                currentValue = value;
+                runLength = 1;
+            }
+        }
+    }
+    runs.push(runLength);
+    return {
+        bounds: maxX < 0
+            ? null
+            : {
+                height: maxY - minY + 1,
+                width: maxX - minX + 1,
+                x: minX + (maxX - minX + 1) / 2,
+                y: minY + (maxY - minY + 1) / 2,
+            },
+        mask: {
+            counts: encodeCompressedRleCounts(runs),
+            encoding: DetectionMaskEncoding.CompressedRle,
+            height,
+            width,
+        },
+    };
+}
+function encodeDetectionMaskPayload(mask, codec) {
+    return codec ? codec.deflate(mask.counts) : mask.counts;
+}
+function decodeDetectionMaskPayload(payload, width, height, options = {}) {
+    const format = options.format ??
+        (isDeflatedBase64DetectionMaskPayload(payload)
+            ? DetectionMaskPayloadFormat.DeflatedBase64
+            : DetectionMaskPayloadFormat.RawCocoRle);
+    if (format === DetectionMaskPayloadFormat.DeflatedBase64 && !options.codec) {
+        throw new Error("A detection mask compression codec is required for deflated payloads.");
+    }
+    return {
+        counts: format === DetectionMaskPayloadFormat.DeflatedBase64
+            ? options.codec.inflate(payload)
+            : payload,
+        encoding: DetectionMaskEncoding.CompressedRle,
+        height,
+        width,
+    };
+}
+/** Matches the annotation editor's legacy transport-format heuristic. */
+function isDeflatedBase64DetectionMaskPayload(value) {
+    return value.length > 100 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}
+function computeMaskBounds(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    let minX = width;
+    let minY = height;
+    let maxX = -1;
+    let maxY = -1;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            if (!data[y * width + x]) {
+                continue;
+            }
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+    }
+    if (maxX < 0) {
+        return null;
+    }
+    const boundsWidth = maxX - minX + 1;
+    const boundsHeight = maxY - minY + 1;
+    return {
+        height: boundsHeight,
+        width: boundsWidth,
+        x: minX + boundsWidth / 2,
+        y: minY + boundsHeight / 2,
+    };
+}
+function computeDetectionMaskRect(mask) {
+    const decoded = decodeCompressedRleMask(mask);
+    const bounds = computeMaskBounds(decoded.data, decoded.width, decoded.height);
+    return bounds ?? undefined;
+}
+function detectMaskBorders(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const borders = new Uint8Array(data.length);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const offset = y * width + x;
+            if (!data[offset]) {
+                continue;
+            }
+            if (x === 0 ||
+                y === 0 ||
+                x === width - 1 ||
+                y === height - 1 ||
+                !data[offset - 1] ||
+                !data[offset + 1] ||
+                !data[offset - width] ||
+                !data[offset + width]) {
+                borders[offset] = 1;
+            }
+        }
+    }
+    return borders;
+}
+function extractMaskContour(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const stride = Math.max(1, Math.floor(height / 100));
+    const leftEdge = [];
+    const rightEdge = [];
+    for (let y = 0; y < height; y += stride) {
+        let left = -1;
+        let right = -1;
+        for (let x = 0; x < width; x += 1) {
+            if (data[y * width + x]) {
+                left = left === -1 ? x : left;
+                right = x;
+            }
+        }
+        if (left !== -1) {
+            leftEdge.push({ x: left, y });
+            rightEdge.push({ x: right, y });
+        }
+    }
+    return leftEdge.length < 2
+        ? undefined
+        : [...leftEdge, ...rightEdge.reverse()];
+}
+function extractMaskRectRuns(data, width, height) {
+    assertMaskDimensions(data, width, height);
+    const rects = [];
+    const openRects = new Map();
+    for (let y = 0; y < height; y += 1) {
+        const activeSpans = new Set();
+        let x = 0;
+        while (x < width) {
+            while (x < width && !data[y * width + x]) {
+                x += 1;
+            }
+            if (x >= width) {
+                break;
+            }
+            const startX = x;
+            while (x < width && data[y * width + x]) {
+                x += 1;
+            }
+            const runWidth = x - startX;
+            const key = `${startX}:${runWidth}`;
+            const openRect = openRects.get(key);
+            activeSpans.add(key);
+            if (openRect && openRect.y + openRect.height === y) {
+                openRects.set(key, { ...openRect, height: openRect.height + 1 });
+            }
+            else {
+                if (openRect) {
+                    rects.push(openRect);
+                }
+                openRects.set(key, { height: 1, width: runWidth, x: startX, y });
+            }
+        }
+        for (const [key, openRect] of openRects) {
+            if (!activeSpans.has(key)) {
+                rects.push(openRect);
+                openRects.delete(key);
+            }
+        }
+    }
+    rects.push(...openRects.values());
+    return rects.length > 0 ? rects : undefined;
+}
+function assertMaskDimensions(data, width, height) {
+    if (!Number.isInteger(width) || width <= 0) {
+        throw new Error("Mask width must be a positive integer.");
+    }
+    if (!Number.isInteger(height) || height <= 0) {
+        throw new Error("Mask height must be a positive integer.");
+    }
+    if (data.length !== width * height) {
+        throw new Error("Mask data length must equal width * height.");
+    }
+}
+
+function centerRectToTopLeftRect(rect) {
+    return {
+        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;
@@ -1773,6 +3735,216 @@ function rectArea(rect) {
     return rect ? Math.max(0, rect.width) * Math.max(0, rect.height) : 0;
 }
 
+const DEFAULT_LOST_TRACK_BUFFER = 30;
+const DEFAULT_FRAME_RATE = 30;
+const DEFAULT_TRACK_ACTIVATION_THRESHOLD = 0.25;
+const DEFAULT_MINIMUM_CONSECUTIVE_FRAMES = 3;
+const DEFAULT_MINIMUM_IOU_THRESHOLD = 0.3;
+const DEFAULT_BYTE_TRACK_ACTIVATION_THRESHOLD = 0.7;
+const DEFAULT_BYTE_MINIMUM_CONSECUTIVE_FRAMES = 2;
+const DEFAULT_BYTE_MINIMUM_IOU_THRESHOLD = 0.1;
+const DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD = 0.6;
+const DEFAULT_CBIOU_FIRST_IOU_THRESHOLD = 0.2;
+const DEFAULT_CBIOU_SECOND_IOU_THRESHOLD = 0.5;
+const DEFAULT_CBIOU_UNCONFIRMED_IOU_THRESHOLD = 0.3;
+const DEFAULT_CBIOU_FIRST_BUFFER_RATIO = 0.3;
+const DEFAULT_CBIOU_SECOND_BUFFER_RATIO = 0.5;
+const DEFAULT_OCSORT_DIRECTION_CONSISTENCY_WEIGHT = 0.2;
+const DEFAULT_OCSORT_DELTA_T = 3;
+const detectionPostProcessors = {
+    tracking: ((options = {}) => {
+        const isByteTrack = options.algorithm === "bytetrack";
+        const isCBIoU = options.algorithm === "cbiou";
+        const isOCSort = options.algorithm === "ocsort";
+        const lostTrackBuffer = normalizeNonNegativeInteger(options.lostTrackBuffer, DEFAULT_LOST_TRACK_BUFFER, "lostTrackBuffer");
+        const frameRate = options.frameRate ?? DEFAULT_FRAME_RATE;
+        const trackActivationThreshold = options.trackActivationThreshold ??
+            (isByteTrack || isCBIoU
+                ? DEFAULT_BYTE_TRACK_ACTIVATION_THRESHOLD
+                : DEFAULT_TRACK_ACTIVATION_THRESHOLD);
+        const minimumConsecutiveFrames = normalizePositiveInteger(options.minimumConsecutiveFrames, isByteTrack || isCBIoU
+            ? DEFAULT_BYTE_MINIMUM_CONSECUTIVE_FRAMES
+            : DEFAULT_MINIMUM_CONSECUTIVE_FRAMES, "minimumConsecutiveFrames");
+        const minimumIouThreshold = options.minimumIouThreshold ??
+            (isByteTrack
+                ? DEFAULT_BYTE_MINIMUM_IOU_THRESHOLD
+                : DEFAULT_MINIMUM_IOU_THRESHOLD);
+        if (!Number.isFinite(frameRate) || frameRate <= 0) {
+            throw new Error("frameRate must be a finite positive value.");
+        }
+        normalizeUnitInterval(trackActivationThreshold, "trackActivationThreshold");
+        normalizeUnitInterval(minimumIouThreshold, "minimumIouThreshold");
+        const base = {
+            geometry: options.geometry ?? TrackingGeometry.Box,
+            kind: "tracking",
+        };
+        if (isCBIoU) {
+            const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ??
+                DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD;
+            const minimumIouThresholdFirstAssociation = options.minimumIouThresholdFirstAssociation ??
+                DEFAULT_CBIOU_FIRST_IOU_THRESHOLD;
+            const minimumIouThresholdSecondAssociation = options.minimumIouThresholdSecondAssociation ??
+                DEFAULT_CBIOU_SECOND_IOU_THRESHOLD;
+            const minimumIouThresholdUnconfirmedAssociation = options.minimumIouThresholdUnconfirmedAssociation ??
+                DEFAULT_CBIOU_UNCONFIRMED_IOU_THRESHOLD;
+            const bufferRatioFirst = options.bufferRatioFirst ?? DEFAULT_CBIOU_FIRST_BUFFER_RATIO;
+            const bufferRatioSecond = options.bufferRatioSecond ?? DEFAULT_CBIOU_SECOND_BUFFER_RATIO;
+            normalizeUnitInterval(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+            normalizeUnitInterval(minimumIouThresholdFirstAssociation, "minimumIouThresholdFirstAssociation");
+            normalizeUnitInterval(minimumIouThresholdSecondAssociation, "minimumIouThresholdSecondAssociation");
+            normalizeUnitInterval(minimumIouThresholdUnconfirmedAssociation, "minimumIouThresholdUnconfirmedAssociation");
+            normalizeNonNegativeFinite(bufferRatioFirst, "bufferRatioFirst");
+            normalizeNonNegativeFinite(bufferRatioSecond, "bufferRatioSecond");
+            return {
+                ...base,
+                algorithm: "cbiou",
+                options: {
+                    bufferRatioFirst,
+                    bufferRatioSecond,
+                    frameRate,
+                    highConfidenceDetectionThreshold,
+                    instantFirstFrameActivation: options.instantFirstFrameActivation ?? true,
+                    lostTrackBuffer,
+                    minimumConsecutiveFrames,
+                    minimumIouThresholdFirstAssociation,
+                    minimumIouThresholdSecondAssociation,
+                    minimumIouThresholdUnconfirmedAssociation,
+                    trackActivationThreshold,
+                },
+            };
+        }
+        if (isOCSort) {
+            const directionConsistencyWeight = options.directionConsistencyWeight ??
+                DEFAULT_OCSORT_DIRECTION_CONSISTENCY_WEIGHT;
+            const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ??
+                DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD;
+            const deltaT = normalizePositiveInteger(options.deltaT, DEFAULT_OCSORT_DELTA_T, "deltaT");
+            normalizeUnitInterval(directionConsistencyWeight, "directionConsistencyWeight");
+            normalizeUnitInterval(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+            return {
+                ...base,
+                algorithm: "ocsort",
+                options: {
+                    deltaT,
+                    directionConsistencyWeight,
+                    frameRate,
+                    highConfidenceDetectionThreshold,
+                    lostTrackBuffer,
+                    minimumConsecutiveFrames,
+                    minimumIouThreshold,
+                },
+            };
+        }
+        if (isByteTrack) {
+            const highConfidenceDetectionThreshold = options.highConfidenceDetectionThreshold ??
+                DEFAULT_HIGH_CONFIDENCE_DETECTION_THRESHOLD;
+            normalizeUnitInterval(highConfidenceDetectionThreshold, "highConfidenceDetectionThreshold");
+            return {
+                ...base,
+                algorithm: "bytetrack",
+                options: {
+                    frameRate,
+                    highConfidenceDetectionThreshold,
+                    lostTrackBuffer,
+                    minimumConsecutiveFrames,
+                    minimumIouThreshold,
+                    trackActivationThreshold,
+                },
+            };
+        }
+        return {
+            ...base,
+            algorithm: "sort",
+            options: {
+                frameRate,
+                lostTrackBuffer,
+                minimumConsecutiveFrames,
+                minimumIouThreshold,
+                trackActivationThreshold,
+            },
+        };
+    }),
+};
+/**
+ * Creates the lightweight projection sent to a tracker or tracking worker.
+ * Masks and keypoint arrays never cross the worker boundary.
+ */
+function projectDetectionFrameForTracking(frame, geometry) {
+    return frame.detections.flatMap((detection, detectionIndex) => {
+        const rect = resolveTrackingRect(detection, geometry);
+        if (!rect || rect.width <= 0 || rect.height <= 0) {
+            return [];
+        }
+        return [
+            {
+                ...(detection.confidence === undefined
+                    ? {}
+                    : { confidence: detection.confidence }),
+                detectionIndex,
+                rect,
+            },
+        ];
+    });
+}
+function resolveTrackingRect(detection, geometry) {
+    switch (geometry) {
+        case TrackingGeometry.Box:
+            return detection.rect;
+        case TrackingGeometry.Mask:
+            if (!detection.mask) {
+                return undefined;
+            }
+            // Most segmentation producers already supply the exact mask bounds as a
+            // rect. Decode RLE only when that inexpensive projection is absent.
+            return detection.rect ?? computeDetectionMaskRect(detection.mask);
+        case TrackingGeometry.Keypoints:
+            return detection.keypoints
+                ? getPointsRect(detection.keypoints.points)
+                : undefined;
+    }
+}
+function normalizePositiveInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return resolved;
+}
+function normalizeNonNegativeInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved < 0) {
+        throw new Error(`${label} must be a non-negative integer.`);
+    }
+    return resolved;
+}
+function normalizeUnitInterval(value, label) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`${label} must be between 0 and 1.`);
+    }
+}
+function normalizeNonNegativeFinite(value, label) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${label} must be a finite non-negative value.`);
+    }
+}
+
+var DetectionPickTarget;
+(function (DetectionPickTarget) {
+    DetectionPickTarget["Box"] = "box";
+    DetectionPickTarget["Edge"] = "edge";
+    DetectionPickTarget["Keypoint"] = "keypoint";
+    DetectionPickTarget["Label"] = "label";
+    DetectionPickTarget["Mask"] = "mask";
+    DetectionPickTarget["Polygon"] = "polygon";
+    DetectionPickTarget["Polyline"] = "polyline";
+})(DetectionPickTarget || (DetectionPickTarget = {}));
+var MediaInteractionMode;
+(function (MediaInteractionMode) {
+    MediaInteractionMode["Always"] = "always";
+    MediaInteractionMode["Disabled"] = "disabled";
+    MediaInteractionMode["PausedOnly"] = "pausedOnly";
+})(MediaInteractionMode || (MediaInteractionMode = {}));
+
 const decodedMaskCache = new WeakMap();
 function pickDetectionAtPoint(frame, point, options = {}) {
     if (!frame) {
@@ -4284,242 +6456,6 @@ function normalizeGlobalKeypointStyle(style) {
     return style === undefined ? new BaseKeypointStyle() : style;
 }
 
-var DetectionMaskPayloadFormat;
-(function (DetectionMaskPayloadFormat) {
-    DetectionMaskPayloadFormat["RawCocoRle"] = "rawCocoRle";
-    DetectionMaskPayloadFormat["DeflatedBase64"] = "deflatedBase64";
-})(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));
-function encodeBinaryMask(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const runs = [];
-    let currentValue = 0;
-    let runLength = 0;
-    for (let x = 0; x < width; x += 1) {
-        for (let y = 0; y < height; y += 1) {
-            const value = data[y * width + x] ? 1 : 0;
-            if (value === currentValue) {
-                runLength += 1;
-            }
-            else {
-                runs.push(runLength);
-                currentValue = value;
-                runLength = 1;
-            }
-        }
-    }
-    runs.push(runLength);
-    return {
-        counts: encodeCompressedRleCounts(runs),
-        encoding: DetectionMaskEncoding.CompressedRle,
-        height,
-        width,
-    };
-}
-/** Encodes a binary mask and derives its bounds in the same raster traversal. */
-function encodeBinaryMaskWithBounds(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const runs = [];
-    let currentValue = 0;
-    let runLength = 0;
-    let minX = width;
-    let minY = height;
-    let maxX = -1;
-    let maxY = -1;
-    for (let x = 0; x < width; x += 1) {
-        for (let y = 0; y < height; y += 1) {
-            const value = data[y * width + x] ? 1 : 0;
-            if (value) {
-                minX = Math.min(minX, x);
-                minY = Math.min(minY, y);
-                maxX = Math.max(maxX, x);
-                maxY = Math.max(maxY, y);
-            }
-            if (value === currentValue) {
-                runLength += 1;
-            }
-            else {
-                runs.push(runLength);
-                currentValue = value;
-                runLength = 1;
-            }
-        }
-    }
-    runs.push(runLength);
-    return {
-        bounds: maxX < 0
-            ? null
-            : {
-                height: maxY - minY + 1,
-                width: maxX - minX + 1,
-                x: minX + (maxX - minX + 1) / 2,
-                y: minY + (maxY - minY + 1) / 2,
-            },
-        mask: {
-            counts: encodeCompressedRleCounts(runs),
-            encoding: DetectionMaskEncoding.CompressedRle,
-            height,
-            width,
-        },
-    };
-}
-function encodeDetectionMaskPayload(mask, codec) {
-    return codec ? codec.deflate(mask.counts) : mask.counts;
-}
-function decodeDetectionMaskPayload(payload, width, height, options = {}) {
-    const format = options.format ??
-        (isDeflatedBase64DetectionMaskPayload(payload)
-            ? DetectionMaskPayloadFormat.DeflatedBase64
-            : DetectionMaskPayloadFormat.RawCocoRle);
-    if (format === DetectionMaskPayloadFormat.DeflatedBase64 && !options.codec) {
-        throw new Error("A detection mask compression codec is required for deflated payloads.");
-    }
-    return {
-        counts: format === DetectionMaskPayloadFormat.DeflatedBase64
-            ? options.codec.inflate(payload)
-            : payload,
-        encoding: DetectionMaskEncoding.CompressedRle,
-        height,
-        width,
-    };
-}
-/** Matches the annotation editor's legacy transport-format heuristic. */
-function isDeflatedBase64DetectionMaskPayload(value) {
-    return value.length > 100 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
-}
-function computeMaskBounds(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    let minX = width;
-    let minY = height;
-    let maxX = -1;
-    let maxY = -1;
-    for (let y = 0; y < height; y += 1) {
-        for (let x = 0; x < width; x += 1) {
-            if (!data[y * width + x]) {
-                continue;
-            }
-            minX = Math.min(minX, x);
-            minY = Math.min(minY, y);
-            maxX = Math.max(maxX, x);
-            maxY = Math.max(maxY, y);
-        }
-    }
-    if (maxX < 0) {
-        return null;
-    }
-    const boundsWidth = maxX - minX + 1;
-    const boundsHeight = maxY - minY + 1;
-    return {
-        height: boundsHeight,
-        width: boundsWidth,
-        x: minX + boundsWidth / 2,
-        y: minY + boundsHeight / 2,
-    };
-}
-function computeDetectionMaskRect(mask) {
-    const decoded = decodeCompressedRleMask(mask);
-    const bounds = computeMaskBounds(decoded.data, decoded.width, decoded.height);
-    return bounds ?? undefined;
-}
-function detectMaskBorders(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const borders = new Uint8Array(data.length);
-    for (let y = 0; y < height; y += 1) {
-        for (let x = 0; x < width; x += 1) {
-            const offset = y * width + x;
-            if (!data[offset]) {
-                continue;
-            }
-            if (x === 0 ||
-                y === 0 ||
-                x === width - 1 ||
-                y === height - 1 ||
-                !data[offset - 1] ||
-                !data[offset + 1] ||
-                !data[offset - width] ||
-                !data[offset + width]) {
-                borders[offset] = 1;
-            }
-        }
-    }
-    return borders;
-}
-function extractMaskContour(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const stride = Math.max(1, Math.floor(height / 100));
-    const leftEdge = [];
-    const rightEdge = [];
-    for (let y = 0; y < height; y += stride) {
-        let left = -1;
-        let right = -1;
-        for (let x = 0; x < width; x += 1) {
-            if (data[y * width + x]) {
-                left = left === -1 ? x : left;
-                right = x;
-            }
-        }
-        if (left !== -1) {
-            leftEdge.push({ x: left, y });
-            rightEdge.push({ x: right, y });
-        }
-    }
-    return leftEdge.length < 2
-        ? undefined
-        : [...leftEdge, ...rightEdge.reverse()];
-}
-function extractMaskRectRuns(data, width, height) {
-    assertMaskDimensions(data, width, height);
-    const rects = [];
-    const openRects = new Map();
-    for (let y = 0; y < height; y += 1) {
-        const activeSpans = new Set();
-        let x = 0;
-        while (x < width) {
-            while (x < width && !data[y * width + x]) {
-                x += 1;
-            }
-            if (x >= width) {
-                break;
-            }
-            const startX = x;
-            while (x < width && data[y * width + x]) {
-                x += 1;
-            }
-            const runWidth = x - startX;
-            const key = `${startX}:${runWidth}`;
-            const openRect = openRects.get(key);
-            activeSpans.add(key);
-            if (openRect && openRect.y + openRect.height === y) {
-                openRects.set(key, { ...openRect, height: openRect.height + 1 });
-            }
-            else {
-                if (openRect) {
-                    rects.push(openRect);
-                }
-                openRects.set(key, { height: 1, width: runWidth, x: startX, y });
-            }
-        }
-        for (const [key, openRect] of openRects) {
-            if (!activeSpans.has(key)) {
-                rects.push(openRect);
-                openRects.delete(key);
-            }
-        }
-    }
-    rects.push(...openRects.values());
-    return rects.length > 0 ? rects : undefined;
-}
-function assertMaskDimensions(data, width, height) {
-    if (!Number.isInteger(width) || width <= 0) {
-        throw new Error("Mask width must be a positive integer.");
-    }
-    if (!Number.isInteger(height) || height <= 0) {
-        throw new Error("Mask height must be a positive integer.");
-    }
-    if (data.length !== width * height) {
-        throw new Error("Mask data length must equal width * height.");
-    }
-}
-
 function rectToPolygon(rect) {
     const halfWidth = rect.width / 2;
     const halfHeight = rect.height / 2;
@@ -4992,6 +6928,30 @@ var MediaRendererPlaybackState;
     MediaRendererPlaybackState["Error"] = "error";
     MediaRendererPlaybackState["Destroyed"] = "destroyed";
 })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));
+/**
+ * Stable classification of a media failure.
+ *
+ * Applications branch on these kinds instead of parsing decoder, demuxer, or
+ * container error text, and still own their localized user-facing copy. New
+ * kinds may be added over time, so treat unrecognized values like `Unknown`.
+ */
+var MediaErrorKind;
+(function (MediaErrorKind) {
+    /** The media could not be opened or read at all. */
+    MediaErrorKind["Unreadable"] = "unreadable";
+    /** The container or codec is not supported by this platform. */
+    MediaErrorKind["UnsupportedFormat"] = "unsupportedFormat";
+    /** The media opened but carries no usable video track. */
+    MediaErrorKind["NoVideoTrack"] = "noVideoTrack";
+    /** Decoding a sample failed after the source opened. */
+    MediaErrorKind["Decode"] = "decode";
+    /** The media could not be fetched. */
+    MediaErrorKind["Network"] = "network";
+    /** The host environment lacks the APIs this media source requires. */
+    MediaErrorKind["EnvironmentUnsupported"] = "environmentUnsupported";
+    /** The failure could not be classified. */
+    MediaErrorKind["Unknown"] = "unknown";
+})(MediaErrorKind || (MediaErrorKind = {}));
 /**
  * Lower-level media source readiness.
  */
@@ -5060,5 +7020,5 @@ var MediaSessionActivityStatus;
     MediaSessionActivityStatus["Waiting"] = "waiting";
 })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));
 
-export { AnnotationFrameMutationKind, AnnotationGeometryKind, AnnotationGestureStateKind, AnnotationHandleKind, BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, StrokeAlignment as BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionMaskPayloadFormat, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MAX_ID_MASK_PALETTE_ENTRIES, MAX_ID_MASK_STROKE_WIDTH, MarkerShape, MarkerSizeSpace, MaskRenderMode, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, RegionRendererComposeMode, RegionRendererRegionKind, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, ShapeInstructionKind, StrokeAlignment, annotationRendererKinds, annotationRenderers, applyAnnotationHandleDrag, canReuseMaskStyleArtifacts, centerRectToTopLeftRect, computeDetectionMaskRect, computeMaskBounds, containsPoint, convertDetectionBoxToMask, convertDetectionBoxToPolygon, convertDetectionMaskToBox, convertDetectionMaskToPolygon, convertDetectionPolygonToBox, convertDetectionPolygonToMask, copySortedDetectionFrames, createAnnotationEditingEngine, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createDetectionPickKey, createEditableAnnotationFrameSession, createIdMaskFrame, createIdleDetectionBufferState, createMemoryColdDetectionFrameStore, createSourceAwarePresentation, createViewportController, createWritableDetectionFrameSource, decodeCompressedRleCounts, decodeCompressedRleMask, decodeDetectionMaskPayload, deleteAnnotationVertex, detectMaskBorders, detectionFrameOverlapsRange, distanceToSegment, encodeBinaryMask, encodeBinaryMaskWithBounds, encodeCompressedRleCounts, encodeDetectionMaskPayload, extractMaskContour, extractMaskRectRuns, filterDetectionFramesForRange, findClosestAnnotationSegment, followDetectionPickAcrossFrames, getAnnotationHandles, getBufferedDetectionTimelineFrameSnapshot, getDetectionRect, getPointsRect, haveSameDetectionPickIdentities, includeDefined, isDeflatedBase64DetectionMaskPayload, lightenColor, mediaToScreen, mergeDetectionMasks, mergeDetectionPolygonsByClass, normalizeDetectionClassName, offsetDetection, pickAnnotationHandle, pickDetectionAtPoint, pickDetectionByMaskId, pointInPolygon, polygonArea, polygonToRect, rasterizePolygonToMask, rasterizeRectToMask, rebaseDetectionPickToFrame, rectArea, rectToPolygon, resolveAnnotationRendererPresentation, resolveAnnotationStyleState, resolveContrastTextColor, resolveDetectionClassColorStyle, resolveEllipseSegmentCount, resolveMarkerGeometry, resolveMaskStyleOpacity, resolveStyleValue, sampleEllipseArc, screenToMedia, selectDetectionFrame, topLeftRectToCenterRect, validateDetectionFrames };
+export { AnnotationFrameMutationKind, AnnotationGeometryKind, AnnotationGestureStateKind, AnnotationHandleKind, BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, StrokeAlignment as BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DetectionBufferStatus, DetectionFrameRetentionMode, DetectionFrameSelectionMode, DetectionInteractionState, DetectionMaskEncoding, DetectionMaskPayloadFormat, DetectionPickTarget, FocusTargetMode, KeypointMarkerShape, KeypointVisibility, LabelPlacement, LabelVisibilityMode, MAX_ID_MASK_PALETTE_ENTRIES, MAX_ID_MASK_STROKE_WIDTH, MarkerShape, MarkerSizeSpace, MaskRenderMode, MediaErrorKind, 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, createProjectedDetectionFrameSource, 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, projectDetectionFrame, projectDetectionFrameForTracking, projectDetectionFrames, rasterizePolygonToMask, rasterizeRectToMask, rebaseDetectionPickToFrame, rectArea, rectToPolygon, resolveAnnotationRendererPresentation, resolveAnnotationStyleState, resolveContrastTextColor, resolveDetectionClassColorStyle, resolveEllipseSegmentCount, resolveMarkerGeometry, resolveMaskStyleOpacity, resolveStyleValue, sampleEllipseArc, screenToMedia, selectDetectionFrame, topLeftRectToCenterRect, validateDetectionFrames };
 //# sourceMappingURL=index.js.map