supervision 0.1.5 → 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) {
@@ -888,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]));
@@ -899,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;
     }
@@ -918,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
@@ -979,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) {
@@ -1001,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;
@@ -1037,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) {
@@ -1070,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) {
@@ -1284,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);
@@ -1322,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);
@@ -1344,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;
@@ -1387,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) {
@@ -1401,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;
@@ -1418,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;
@@ -1449,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 (!Number.isFinite(endTime)) {
+                throw new RangeError("finalizeCoverage requires a finite endTime.");
             }
-            if (changedSourceRanges.length === 0) {
-                summary = nextSummary;
-                return nextSummary;
-            }
-            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();
@@ -1513,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: [],
@@ -1528,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,
@@ -1563,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 ||
@@ -1576,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) {
@@ -1610,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);
@@ -6337,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.
  */
@@ -6405,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, TrackingGeometry, annotationRendererKinds, annotationRenderers, applyAnnotationHandleDrag, canReuseMaskStyleArtifacts, centerRectToTopLeftRect, computeDetectionMaskRect, computeMaskBounds, containsPoint, convertDetectionBoxToMask, convertDetectionBoxToPolygon, convertDetectionMaskToBox, convertDetectionMaskToPolygon, convertDetectionPolygonToBox, convertDetectionPolygonToMask, copySortedDetectionFrames, createAnnotationEditingEngine, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createDetectionPickKey, createEditableAnnotationFrameSession, createIdMaskFrame, createIdleDetectionBufferState, createMemoryColdDetectionFrameStore, createOCSortTracker, createSortTracker, createSourceAwarePresentation, createViewportController, createWritableDetectionFrameSource, decodeCompressedRleCounts, decodeCompressedRleMask, decodeDetectionMaskPayload, deleteAnnotationVertex, detectMaskBorders, detectionFrameOverlapsRange, detectionPostProcessors, distanceToSegment, encodeBinaryMask, encodeBinaryMaskWithBounds, encodeCompressedRleCounts, encodeDetectionMaskPayload, extractMaskContour, extractMaskRectRuns, filterDetectionFramesForRange, findClosestAnnotationSegment, followDetectionPickAcrossFrames, getAnnotationHandles, getBufferedDetectionTimelineFrameSnapshot, getDetectionRect, getPointsRect, haveSameDetectionPickIdentities, includeDefined, isDeflatedBase64DetectionMaskPayload, lightenColor, mediaToScreen, mergeDetectionMasks, mergeDetectionPolygonsByClass, normalizeDetectionClassName, offsetDetection, pickAnnotationHandle, pickDetectionAtPoint, pickDetectionByMaskId, pointInPolygon, polygonArea, polygonToRect, projectDetectionFrameForTracking, rasterizePolygonToMask, rasterizeRectToMask, rebaseDetectionPickToFrame, rectArea, rectToPolygon, resolveAnnotationRendererPresentation, resolveAnnotationStyleState, resolveContrastTextColor, resolveDetectionClassColorStyle, resolveEllipseSegmentCount, resolveMarkerGeometry, resolveMaskStyleOpacity, resolveStyleValue, sampleEllipseArc, screenToMedia, selectDetectionFrame, topLeftRectToCenterRect, validateDetectionFrames };
+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