supervision 0.2.0-next.0 → 0.2.0-next.2

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

@@ -563,8 +563,8 @@ function startWaitBound(timeoutMs) {
     return { cancel: () => clearTimeout(handle), expired };
 }
 
-const DEFAULT_BUFFER_AHEAD_SECONDS = 5;
-const DEFAULT_BUFFER_BEHIND_SECONDS = 0.5;
+const DEFAULT_BUFFER_AHEAD_SECONDS = 10;
+const DEFAULT_BUFFER_BEHIND_SECONDS = 5;
 /**
  * Share of the ahead window that must still lead the playhead when the next
  * window is fetched.
@@ -615,6 +615,7 @@ function createBufferedDetectionTimeline(options) {
         duration: null,
         loop: false,
     };
+    let timelineFirstTimestamp = 0;
     let inFlight;
     let incrementalRefresh;
     /** Source version the gate last gave up on, or null while it still waits. */
@@ -754,14 +755,15 @@ function createBufferedDetectionTimeline(options) {
             state.bufferEndTime === null) {
             return;
         }
-        const laps = Math.round((getComparableMediaTime(mediaTime) - mediaTime) / duration);
+        const loopSpan = duration - timelineFirstTimestamp;
+        const laps = Math.round((getComparableMediaTime(mediaTime) - mediaTime) / loopSpan);
         if (laps === 0) {
             return;
         }
         state = {
             ...state,
-            bufferEndTime: state.bufferEndTime - laps * duration,
-            bufferStartTime: state.bufferStartTime - laps * duration,
+            bufferEndTime: state.bufferEndTime - laps * loopSpan,
+            bufferStartTime: state.bufferStartTime - laps * loopSpan,
         };
         notifyBufferChanged();
     };
@@ -773,6 +775,32 @@ function createBufferedDetectionTimeline(options) {
             comparableMediaTime >= state.bufferStartTime &&
             comparableMediaTime <= state.bufferEndTime);
     };
+    const inFlightCovers = (mediaTime) => {
+        if (!inFlight) {
+            return true;
+        }
+        const comparableMediaTime = getComparableMediaTime(mediaTime);
+        return (comparableMediaTime >= inFlight.startTime &&
+            comparableMediaTime <= inFlight.endTime);
+    };
+    const supersedeLoadOutside = (mediaTime) => {
+        if (!inFlight || inFlightCovers(mediaTime)) {
+            return;
+        }
+        const keepsCurrentBuffer = isBuffered(mediaTime);
+        loadId += 1;
+        inFlight = undefined;
+        if (keepsCurrentBuffer) {
+            state = {
+                ...state,
+                errorMessage: null,
+                requestedEndTime: state.bufferEndTime,
+                requestedStartTime: state.bufferStartTime,
+                status: DetectionBufferStatus.Ready,
+            };
+            notifyBufferChanged();
+        }
+    };
     const isInsideBufferedRange = (mediaTime) => {
         const comparableMediaTime = getComparableMediaTime(mediaTime);
         return (bufferedVersionRange !== null &&
@@ -783,6 +811,11 @@ function createBufferedDetectionTimeline(options) {
     };
     const refreshBuffer = async (mediaTime, lead = "full") => {
         if (isBuffered(mediaTime)) {
+            // A backwards navigation may land in the retained buffer while a rolling
+            // prefetch for the old playhead is about to replace it. The navigation
+            // is current truth; do not let that older load evict its detections after
+            // the frame has been accepted.
+            supersedeLoadOutside(mediaTime);
             return;
         }
         if (isInsideBufferedRange(mediaTime) &&
@@ -833,16 +866,27 @@ function createBufferedDetectionTimeline(options) {
             if (destroyed || !isLoadingEnabled()) {
                 return;
             }
+            adoptFirstTimestamp(prepareOptions?.firstTimestamp);
+            const navigationMediaTime = getNavigationMediaTime(mediaTime);
             if (shouldWaitForPlaybackGate(prepareOptions)) {
-                await waitForPlaybackGate(mediaTime, prepareOptions);
+                await waitForPlaybackGate(navigationMediaTime, prepareOptions);
                 if (destroyed) {
                     return;
                 }
             }
-            await refreshBuffer(mediaTime);
-            anchorWindowToPlayhead(mediaTime);
+            await refreshBuffer(navigationMediaTime);
+            anchorWindowToPlayhead(navigationMediaTime);
+        },
+        needsBufferPrepare(mediaTime) {
+            const navigationMediaTime = getNavigationMediaTime(mediaTime);
+            return (!destroyed &&
+                isLoadingEnabled() &&
+                (!isInsideBufferedRange(navigationMediaTime) ||
+                    !inFlightCovers(navigationMediaTime)));
         },
         needsPlaybackGateWait(mediaTime, prepareOptions) {
+            adoptFirstTimestamp(prepareOptions?.firstTimestamp);
+            const navigationMediaTime = getNavigationMediaTime(mediaTime);
             if (destroyed ||
                 !isLoadingEnabled() ||
                 !playbackGate?.enabled ||
@@ -852,27 +896,31 @@ function createBufferedDetectionTimeline(options) {
                 return false;
             }
             const availableRanges = options.source.getAvailableRanges();
-            return !createPlaybackGateCoveragePlan(mediaTime, prepareOptions).sourceRanges.every((range) => isRangeCovered(range, availableRanges));
+            return !createPlaybackGateCoveragePlan(navigationMediaTime, prepareOptions).sourceRanges.every((range) => isRangeCovered(range, availableRanges));
         },
         prefetch(mediaTime) {
             if (destroyed || !isLoadingEnabled()) {
                 return;
             }
-            anchorWindowToPlayhead(mediaTime);
-            if (!shouldPrefetch(mediaTime)) {
+            const navigationMediaTime = getNavigationMediaTime(mediaTime);
+            anchorWindowToPlayhead(navigationMediaTime);
+            supersedeLoadOutside(navigationMediaTime);
+            if (!shouldPrefetch(navigationMediaTime)) {
                 return;
             }
-            pendingPrefetch = { loadId, mediaTime };
+            pendingPrefetch = { loadId, mediaTime: navigationMediaTime };
             pumpPrefetchQueue();
         },
         selectFrame(mediaTime) {
-            if (!isBuffered(mediaTime)) {
+            const navigationMediaTime = getNavigationMediaTime(mediaTime);
+            if (!isInsideBufferedRange(navigationMediaTime)) {
                 return undefined;
             }
-            return selectDetectionFrame(buffer, getSourceMediaTime(mediaTime), options);
+            return selectDetectionFrame(buffer, getSourceMediaTime(navigationMediaTime), options);
         },
         setTimelineContext(context) {
             timelineContext = context;
+            adoptFirstTimestamp(context.firstTimestamp);
             bufferedSourceVersion = null;
             bufferedVersionRange = null;
         },
@@ -1008,12 +1056,12 @@ function createBufferedDetectionTimeline(options) {
     }
     function createPlaybackGateCoveragePlan(mediaTime, prepareOptions) {
         const requiredAheadSeconds = Math.max(0, playbackGate?.requiredAheadSeconds ?? 0);
-        const comparableMediaTime = getComparableMediaTime(mediaTime);
+        const comparableMediaTime = Math.max(timelineFirstTimestamp, getComparableMediaTime(mediaTime));
         const endTime = getRequiredCoverageEndTime({
             // A looping window counts past the end of media and wraps into the
             // replay, so clamping it to duration would ask for less than it needs.
             duration: isLoopingTimeline() ? null : prepareOptions?.duration,
-            firstTimestamp: prepareOptions?.firstTimestamp,
+            firstTimestamp: timelineFirstTimestamp,
             mediaTime: comparableMediaTime,
             requiredAheadSeconds,
         });
@@ -1100,21 +1148,23 @@ function createBufferedDetectionTimeline(options) {
      * a looping timeline. A plan is stated on the first lap and the window on the
      * playhead's, so across the loop point the two state the same edge a whole lap
      * apart; measured straight, that reads as a window a full lap stale and
-     * rebuilds it on every frame until the plan stops reaching behind zero.
+     * rebuilds it on every frame until the plan stops reaching behind the first
+     * playable timestamp.
      */
     function getWindowDrift(planTime, bufferTime) {
         const drift = Math.abs(planTime - bufferTime);
         if (!isLoopingTimeline() || timelineContext.duration === null) {
             return drift;
         }
-        const wrappedDrift = modulo(drift, timelineContext.duration);
-        return Math.min(wrappedDrift, timelineContext.duration - wrappedDrift);
+        const loopSpan = timelineContext.duration - timelineFirstTimestamp;
+        const wrappedDrift = modulo(drift, loopSpan);
+        return Math.min(wrappedDrift, loopSpan - wrappedDrift);
     }
     function createLoadPlan(requestedStartTime, requestedEndTime) {
         const startTime = Math.min(requestedStartTime, requestedEndTime);
         const endTime = Math.max(startTime, requestedEndTime);
         if (!isLoopingTimeline()) {
-            const clampedStartTime = Math.max(0, startTime);
+            const clampedStartTime = Math.max(timelineFirstTimestamp, startTime);
             const clampedEndTime = Math.max(clampedStartTime, endTime);
             return {
                 endTime: clampedEndTime,
@@ -1128,22 +1178,25 @@ function createBufferedDetectionTimeline(options) {
             };
         }
         const duration = timelineContext.duration ?? 0;
-        if (endTime - startTime >= duration) {
+        const loopSpan = duration - timelineFirstTimestamp;
+        if (endTime - startTime >= loopSpan) {
             return {
                 endTime: duration,
-                sourceRanges: [{ endTime: duration, startTime: 0 }],
-                startTime: 0,
+                sourceRanges: [
+                    { endTime: duration, startTime: timelineFirstTimestamp },
+                ],
+                startTime: timelineFirstTimestamp,
             };
         }
         // Both ends move by the same whole number of laps, so the window keeps its
         // span and its source ranges while its start reads on the media clock: a
         // window counted in the laps playback accumulated is one no host can hold
         // against a current time.
-        const laps = Math.floor(startTime / duration);
+        const laps = Math.floor((startTime - timelineFirstTimestamp) / loopSpan);
         return {
-            endTime: endTime - laps * duration,
-            sourceRanges: getLoopingSourceRanges(startTime, endTime, duration),
-            startTime: startTime - laps * duration,
+            endTime: endTime - laps * loopSpan,
+            sourceRanges: getLoopingSourceRanges(startTime, endTime, duration, timelineFirstTimestamp),
+            startTime: startTime - laps * loopSpan,
         };
     }
     function getBufferedSourceRanges() {
@@ -1155,7 +1208,7 @@ function createBufferedDetectionTimeline(options) {
     function isLoopingTimeline() {
         return (timelineContext.loop &&
             timelineContext.duration !== null &&
-            timelineContext.duration > 0);
+            timelineContext.duration > timelineFirstTimestamp);
     }
     function getComparableMediaTime(mediaTime) {
         if (!isLoopingTimeline() ||
@@ -1164,23 +1217,42 @@ function createBufferedDetectionTimeline(options) {
             timelineContext.duration === null) {
             return mediaTime;
         }
-        const duration = timelineContext.duration;
-        // The representative of mediaTime (mod duration) anchored at the window
+        const loopSpan = timelineContext.duration - timelineFirstTimestamp;
+        // The representative of mediaTime (mod the loop span) anchored at the window
         // start. The mapping must depend only on where the window sits, never on
         // how many laps playback has accumulated, or membership drifts away from
         // what the buffer actually holds. A time less than one lap past the
         // anchor never wraps, so ordinary forward playback cannot ratchet.
         return (state.bufferStartTime +
-            modulo(mediaTime - state.bufferStartTime, duration));
+            modulo(mediaTime - state.bufferStartTime, loopSpan));
     }
     function getSourceMediaTime(mediaTime) {
         if (!isLoopingTimeline() || timelineContext.duration === null) {
             return mediaTime;
         }
-        if (mediaTime >= 0 && mediaTime <= timelineContext.duration) {
+        if (mediaTime >= timelineFirstTimestamp &&
+            mediaTime <= timelineContext.duration) {
             return mediaTime;
         }
-        return modulo(mediaTime, timelineContext.duration);
+        const loopSpan = timelineContext.duration - timelineFirstTimestamp;
+        return (timelineFirstTimestamp +
+            modulo(mediaTime - timelineFirstTimestamp, loopSpan));
+    }
+    function getNavigationMediaTime(mediaTime) {
+        return Math.max(timelineFirstTimestamp, mediaTime);
+    }
+    function adoptFirstTimestamp(firstTimestamp) {
+        if (firstTimestamp === undefined ||
+            !Number.isFinite(firstTimestamp) ||
+            firstTimestamp === timelineFirstTimestamp) {
+            return;
+        }
+        timelineFirstTimestamp = firstTimestamp;
+        loadId += 1;
+        inFlight = undefined;
+        pendingPrefetch = undefined;
+        bufferedSourceVersion = null;
+        bufferedVersionRange = null;
     }
 }
 function createIdleDetectionBufferState() {
@@ -1211,13 +1283,14 @@ function getRequiredCoverageEndTime(options) {
     if (options.duration === null || options.duration === undefined) {
         return requestedEndTime;
     }
-    return Math.min(requestedEndTime, (options.firstTimestamp ?? 0) + Math.max(options.duration, 0));
+    return Math.min(requestedEndTime, Math.max(options.firstTimestamp ?? 0, options.duration));
 }
-function getLoopingSourceRanges(startTime, endTime, duration) {
-    const normalizedStartTime = modulo(startTime, duration);
-    const normalizedEndTime = modulo(endTime, duration);
-    const startCycle = Math.floor(startTime / duration);
-    const endCycle = Math.floor(endTime / duration);
+function getLoopingSourceRanges(startTime, endTime, duration, firstTimestamp = 0) {
+    const loopSpan = duration - firstTimestamp;
+    const normalizedStartTime = firstTimestamp + modulo(startTime - firstTimestamp, loopSpan);
+    const normalizedEndTime = firstTimestamp + modulo(endTime - firstTimestamp, loopSpan);
+    const startCycle = Math.floor((startTime - firstTimestamp) / loopSpan);
+    const endCycle = Math.floor((endTime - firstTimestamp) / loopSpan);
     if (startCycle === endCycle) {
         return [{ endTime: normalizedEndTime, startTime: normalizedStartTime }];
     }
@@ -1225,8 +1298,8 @@ function getLoopingSourceRanges(startTime, endTime, duration) {
     if (normalizedStartTime < duration) {
         ranges.push({ endTime: duration, startTime: normalizedStartTime });
     }
-    if (normalizedEndTime > 0) {
-        ranges.push({ endTime: normalizedEndTime, startTime: 0 });
+    if (normalizedEndTime > firstTimestamp) {
+        ranges.push({ endTime: normalizedEndTime, startTime: firstTimestamp });
     }
     return ranges;
 }
@@ -4033,9 +4106,16 @@ function computeMaskBounds(data, width, height) {
     };
 }
 function computeDetectionMaskRect(mask) {
-    const decoded = decodeCompressedRleMask(mask);
-    const bounds = computeMaskBounds(decoded.data, decoded.width, decoded.height);
-    return bounds ?? undefined;
+    const { bounds } = readCompressedRleMask(mask);
+    if (!bounds) {
+        return undefined;
+    }
+    return {
+        height: bounds.height,
+        width: bounds.width,
+        x: bounds.left + bounds.width / 2,
+        y: bounds.top + bounds.height / 2,
+    };
 }
 function detectMaskBorders(data, width, height) {
     assertMaskDimensions(data, width, height);
@@ -4097,13 +4177,8 @@ function extractMaskRectRuns(data, width, height) {
  * the pass are that box.
  */
 function extractDetectionMaskRectRuns(mask) {
-    if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {
-        throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);
-    }
     const { height, width } = mask;
-    assertMaskSize(width, height);
-    const counts = decodeCompressedRleCounts(mask.counts);
-    const bounds = computeCompressedRleBounds(counts, width, height);
+    const { bounds, counts } = readCompressedRleMask(mask);
     if (!bounds) {
         return undefined;
     }
@@ -4135,6 +4210,17 @@ function extractDetectionMaskRectRuns(mask) {
     const rects = mergeRowSpansIntoRects(boundsBuffer, boundsWidth, boundsHeight, left, top);
     return rects.length > 0 ? rects : undefined;
 }
+function readCompressedRleMask(mask) {
+    if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {
+        throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);
+    }
+    assertMaskSize(mask.width, mask.height);
+    const counts = decodeCompressedRleCounts(mask.counts);
+    return {
+        bounds: computeCompressedRleBounds(counts, mask.width, mask.height),
+        counts,
+    };
+}
 /** Counts alternate background, foreground, starting on background. */
 function isForegroundRun(index) {
     return index % 2 === 1;
@@ -7433,7 +7519,6 @@ function createIdMaskFrame(instructions, options = {}) {
     const height = width === maskWidth
         ? maskHeight
         : Math.max(1, Math.round((width * maskHeight) / maskWidth));
-    const strokeScale = width / maskWidth;
     const scaledAxes = width === maskWidth
         ? undefined
         : createScaledMaskAxes({ height, maskHeight, maskWidth, width });
@@ -7444,18 +7529,17 @@ function createIdMaskFrame(instructions, options = {}) {
     let hasStroke = false;
     let maxStrokeWidth = 0;
     for (const instruction of instructions) {
-        const detectionMaskId = instruction.detectionIndex + 1;
-        if (detectionMaskId <= 0 ||
-            detectionMaskId >= MAX_ID_MASK_PALETTE_ENTRIES) {
+        const detectionMaskId = resolveIdMaskPaletteId(instruction.detectionIndex);
+        if (detectionMaskId === undefined) {
             return undefined;
         }
-        writePaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);
+        writeIdMaskPaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);
         if (instruction.stroke && instruction.stroke.width > 0) {
-            const strokeWidth = Math.min(resolveStrokeTexels(instruction.stroke.width, strokeScale), MAX_ID_MASK_STROKE_WIDTH);
+            const strokeWidth = resolveIdMaskStrokeTexels(instruction.stroke.width, maskWidth, width);
             hasStroke = true;
             strokeWidths[detectionMaskId] = strokeWidth;
             maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);
-            writePaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);
+            writeIdMaskPaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);
         }
         if (scaledAxes) {
             writeScaledMaskRuns(data, scaledAxes, instruction.mask, detectionMaskId);
@@ -7470,6 +7554,7 @@ function createIdMaskFrame(instructions, options = {}) {
         hasStroke,
         height,
         maxStrokeWidth,
+        sourceWidth: maskWidth,
         strokePalette,
         strokeWidths,
         width,
@@ -7552,10 +7637,14 @@ function resolveRasterWidth(maskWidth, maxWidth) {
  * A stroke is measured in texels of the raster it is drawn on, so a coarser
  * raster measures it in coarser texels. A stroke of a texel or more keeps at
  * least one, the thinnest line the shader can draw; a narrower one keeps its
- * own width, which the shader draws as an inner boundary at any scale.
+ * own width, which the shader draws as an inner boundary at any scale. The
+ * ceiling is the widest neighbourhood the shaders scan, so a wider stroke would
+ * be drawn at the ceiling anyway and every layer drawing the same annotation
+ * has to arrive at the same width.
  */
-function resolveStrokeTexels(strokeWidth, scale) {
-    return Math.max(strokeWidth * scale, Math.min(strokeWidth, 1));
+function resolveIdMaskStrokeTexels(strokeWidth, maskWidth, rasterWidth) {
+    const scale = maskWidth > 0 ? rasterWidth / maskWidth : 1;
+    return Math.min(Math.max(strokeWidth * scale, Math.min(strokeWidth, 1)), MAX_ID_MASK_STROKE_WIDTH);
 }
 function createScaledMaskAxes(frame) {
     return {
@@ -7572,8 +7661,19 @@ function createMaskAxisMap(sourceLength, targetLength, stride) {
     }
     return map;
 }
-function writePaletteEntry(palette, id, color, alpha) {
-    const offset = id * 4;
+/**
+ * The palette slot a detection index names, or undefined when the palette has
+ * no slot for it. Slot zero is the background, so the ids start at one and the
+ * last detection the palette can name sits one index below the last slot.
+ */
+function resolveIdMaskPaletteId(detectionIndex) {
+    const detectionMaskId = detectionIndex + 1;
+    return detectionMaskId > 0 && detectionMaskId < MAX_ID_MASK_PALETTE_ENTRIES
+        ? detectionMaskId
+        : undefined;
+}
+function writeIdMaskPaletteEntry(palette, detectionMaskId, color, alpha) {
+    const offset = detectionMaskId * 4;
     palette[offset] = ((color >> 16) & 0xff) / 255;
     palette[offset + 1] = ((color >> 8) & 0xff) / 255;
     palette[offset + 2] = (color & 0xff) / 255;
@@ -7811,7 +7911,7 @@ var MediaRendererPlaybackState;
  */
 var MediaErrorKind;
 (function (MediaErrorKind) {
-    /** The media could not be opened or read at all. */
+    /** The media could not be opened or read, or was refused before any read. */
     MediaErrorKind["Unreadable"] = "unreadable";
     /** The container or codec is not supported by this platform. */
     MediaErrorKind["UnsupportedFormat"] = "unsupportedFormat";
@@ -7845,8 +7945,8 @@ var MediaSourceStatus;
  * A source the renderer pulls samples from can be held between any two frames,
  * because the renderer decides when each one is drawn. A source that presents
  * its own frames owns the playhead, so holding it means stopping the producer
- * and starting it again, which the detection gate does and the
- * render-preparation gate does not.
+ * and starting it again, and a gate that stops one has to bound its own wait
+ * or a producer nothing answers for never runs again.
  */
 var PlaybackGateReach;
 (function (PlaybackGateReach) {
@@ -7857,8 +7957,6 @@ var PlaybackGateReach;
      * missing, until they arrive or the gate's own wait bound gives up on them.
      */
     PlaybackGateReach["EveryFrame"] = "everyFrame";
-    /** Playback waits to begin; frames after that are not held. */
-    PlaybackGateReach["StartOfPlayback"] = "startOfPlayback";
 })(PlaybackGateReach || (PlaybackGateReach = {}));
 
 /**
@@ -7912,7 +8010,23 @@ var MediaSessionActivityKind;
     MediaSessionActivityKind["Error"] = "error";
     MediaSessionActivityKind["MediaNormalizing"] = "mediaNormalizing";
     MediaSessionActivityKind["MediaOpening"] = "mediaOpening";
+    /**
+     * The picture is waiting on media the source has not handed over yet, which
+     * is the bytes and their decode rather than anything downstream of them.
+     * `PlaybackBuffering` is what a transport reports once it has already
+     * stopped; this is reported from the read itself, including the reads a seek
+     * makes while the transport still reads as paused.
+     */
+    MediaSessionActivityKind["MediaSourceReading"] = "mediaSourceReading";
     MediaSessionActivityKind["PlaybackBuffering"] = "playbackBuffering";
+    /**
+     * The render-preparation gate held the picture for artifacts that never
+     * arrived and let it go. Nothing is blocked: the frames reaching the screen
+     * are the ones whose artifacts were given up on. What is waited on is
+     * preparation finishing another frame, which is what lets the gate hold the
+     * picture again; `RenderPreparing` covers the holds that are running.
+     */
+    MediaSessionActivityKind["RenderPreparationAbandoned"] = "renderPreparationAbandoned";
     MediaSessionActivityKind["RenderPreparing"] = "renderPreparing";
 })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));
 /**
@@ -7925,5 +8039,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, MediaErrorKind, MediaInteractionMode, MediaRendererFit, MediaRendererPlaybackState, MediaSessionActivityKind, MediaSessionActivityStatus, MediaSessionMode, MediaSessionStatus, MediaSourceStatus, PlaybackGateReach, RegionRendererComposeMode, RegionRendererCoverageKind, RegionRendererMediaEffectKind, RegionRendererRegionKind, RegionRendererSizeSpace, 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, extractDetectionMaskRectRuns, 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, resolveAnnotationRendererStyleFields, 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, PlaybackGateReach, RegionRendererComposeMode, RegionRendererCoverageKind, RegionRendererMediaEffectKind, RegionRendererRegionKind, RegionRendererSizeSpace, 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, extractDetectionMaskRectRuns, 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, resolveAnnotationRendererStyleFields, resolveAnnotationStyleState, resolveContrastTextColor, resolveDetectionClassColorStyle, resolveEllipseSegmentCount, resolveIdMaskPaletteId, resolveIdMaskStrokeTexels, resolveMarkerGeometry, resolveMaskStyleOpacity, resolveStyleValue, sampleEllipseArc, screenToMedia, selectDetectionFrame, topLeftRectToCenterRect, validateDetectionFrames, writeIdMaskPaletteEntry };
 //# sourceMappingURL=index.js.map