supervision 0.2.5 → 0.2.7

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

@@ -89,6 +89,19 @@ var DetectionFrameRetentionMode;
  * function and not in a smaller number here.
  */
 const PLAYHEAD_QUANTIZATION_TOLERANCE_SECONDS = 0.0005;
+/**
+ * Validates and orders a window without copying it. The frames stay the
+ * caller's own objects, which is what a source wants: `DetectionFrame` and its
+ * `detections` are both `readonly`, nothing in the library writes to either,
+ * and the buffer that receives this window already keeps the objects it
+ * recognises and copies only the ones it does not
+ * (`reuseBufferedFrameSnapshots`). A source that copies first pays for every
+ * frame the buffer is about to discard.
+ */
+function sortedDetectionFrames(detectionFrames) {
+    validateDetectionFrames(detectionFrames ?? []);
+    return [...(detectionFrames ?? [])].sort((left, right) => left.mediaTime - right.mediaTime);
+}
 function copySortedDetectionFrames(detectionFrames) {
     validateDetectionFrames(detectionFrames ?? []);
     return (detectionFrames ?? [])
@@ -668,6 +681,9 @@ function createBufferedDetectionTimeline(options) {
     let state = createIdleDetectionBufferState();
     let destroyed = false;
     let loadId = 0;
+    // Preserve snapshot reuse without retaining evicted geometry.
+    const snapshotByIdentity = new Map();
+    let snapshotSourceVersion = null;
     let bufferedSourceVersion = null;
     let bufferedVersionRange = null;
     let timelineContext = {
@@ -693,6 +709,37 @@ function createBufferedDetectionTimeline(options) {
         }
         return ranges.reduce((version, range) => Math.max(version, options.source.getVersion?.(range) ?? 0), 0);
     };
+    const synchronizeSnapshotMemo = () => {
+        const sourceVersion = getSourceVersion();
+        if (snapshotSourceVersion === sourceVersion) {
+            return;
+        }
+        const frames = [...snapshotByIdentity.values()].flatMap((reference) => {
+            const frame = reference.deref();
+            return frame ? [frame] : [];
+        });
+        const changes = snapshotSourceVersion === null || frames.length === 0
+            ? undefined
+            : options.source.getChangesSince?.(snapshotSourceVersion, [
+                {
+                    startTime: Math.min(...frames.map((frame) => frame.mediaTime)),
+                    endTime: Math.max(...frames.map((frame) => frame.endTime ??
+                        frame.mediaTime +
+                            Number.EPSILON * Math.max(1, Math.abs(frame.mediaTime)))),
+                },
+            ]);
+        if (!changes || changes.requiresReload) {
+            snapshotByIdentity.clear();
+        }
+        else {
+            for (const frame of frames) {
+                if (changes.ranges.some((range) => detectionFrameOverlapsRange(frame, range.startTime, range.endTime))) {
+                    snapshotByIdentity.delete(getDetectionFrameIdentity(frame));
+                }
+            }
+        }
+        snapshotSourceVersion = sourceVersion;
+    };
     const isLoadingEnabled = () => typeof options.enabled === "function"
         ? options.enabled()
         : options.enabled !== false;
@@ -740,14 +787,19 @@ function createBufferedDetectionTimeline(options) {
                 return;
             }
             const committedSourceVersion = getSourceVersion(sourceRanges);
+            const sourceUnchanged = sourceVersion === committedSourceVersion;
             const loadedFrames = frameRanges.flat();
-            buffer =
-                bufferedSourceVersion !== null &&
-                    bufferedSourceVersion === committedSourceVersion
-                    ? reuseBufferedFrameSnapshots(buffer, loadedFrames)
-                    : copySortedDetectionFrames(loadedFrames);
+            synchronizeSnapshotMemo();
+            buffer = sourceUnchanged
+                ? reuseBufferedFrameSnapshots(bufferedSourceVersion === sourceVersion ? buffer : [], loadedFrames, snapshotByIdentity)
+                : copySortedDetectionFrames(loadedFrames);
+            if (sourceUnchanged) {
+                for (const frame of buffer) {
+                    rememberSnapshot(snapshotByIdentity, frame);
+                }
+            }
             bufferedVersionRange = versionRange;
-            bufferedSourceVersion = committedSourceVersion;
+            bufferedSourceVersion = sourceVersion;
             state = {
                 bufferEndTime: endTime,
                 bufferStartTime: startTime,
@@ -1003,6 +1055,8 @@ function createBufferedDetectionTimeline(options) {
             listeners.clear();
             pendingPrefetch = undefined;
             buffer = [];
+            snapshotByIdentity.clear();
+            snapshotSourceVersion = null;
             bufferedSourceVersion = null;
             bufferedVersionRange = null;
             state = {
@@ -1086,7 +1140,14 @@ function createBufferedDetectionTimeline(options) {
                 bufferedVersionRange !== incrementalVersionRange) {
                 return;
             }
-            buffer = mergeIncrementalFrames(buffer, changedFrameRanges.flat(), changedRanges);
+            const changedFrames = copySortedDetectionFrames(changedFrameRanges.flat());
+            synchronizeSnapshotMemo();
+            buffer = mergeIncrementalFrames(buffer, changedFrames, changedRanges);
+            if (getSourceVersion(sourceRanges) === changes.version) {
+                for (const frame of buffer) {
+                    rememberSnapshot(snapshotByIdentity, frame);
+                }
+            }
             bufferedSourceVersion = changes.version;
             state = {
                 ...state,
@@ -1391,18 +1452,36 @@ function mergeIncrementalFrames(currentFrames, changedFrames, changedRanges) {
     }
     return Array.from(framesByIdentity.values()).sort(compareDetectionFrames$1);
 }
-/**
- * Keeps the frame already held wherever the source returned one this buffer
- * knows, and copies only what is new. Copying everything first and then
- * discarding it is the same result for a great deal more work: a window rebuilt
- * while a gesture moves inside it re-derives hundreds of frames it already has.
- */
-function reuseBufferedFrameSnapshots(currentFrames, loadedFrames) {
-    validateDetectionFrames(loadedFrames);
+const MAX_REMEMBERED_SNAPSHOTS = 8192;
+function rememberSnapshot(snapshots, frame) {
+    const identity = getDetectionFrameIdentity(frame);
+    if (snapshots.get(identity)?.deref() === frame) {
+        return;
+    }
+    snapshots.delete(identity);
+    snapshots.set(identity, new WeakRef(frame));
+    while (snapshots.size > MAX_REMEMBERED_SNAPSHOTS) {
+        const oldest = snapshots.keys().next().value;
+        if (oldest === undefined) {
+            break;
+        }
+        snapshots.delete(oldest);
+    }
+}
+/** Reuse unchanged snapshots so moving the window copies only new frames. */
+function reuseBufferedFrameSnapshots(currentFrames, loadedFrames, snapshots) {
     const currentFramesByIdentity = new Map(currentFrames.map((frame) => [getDetectionFrameIdentity(frame), frame]));
     return loadedFrames
-        .map((frame) => currentFramesByIdentity.get(getDetectionFrameIdentity(frame)) ??
-        copyDetectionFrame(frame))
+        .map((frame) => {
+        const identity = getDetectionFrameIdentity(frame);
+        const existing = currentFramesByIdentity.get(identity) ??
+            snapshots.get(identity)?.deref();
+        if (existing) {
+            return existing;
+        }
+        validateDetectionFrames([frame]);
+        return copyDetectionFrame(frame);
+    })
         .sort(compareDetectionFrames$1);
 }
 function getDetectionFrameIdentity(frame) {
@@ -4860,7 +4939,14 @@ function pickDetectionAtPoint(frame, point, options = {}) {
                 zIndex: detection.zIndex ?? detectionIndex,
             });
         };
-        if (detection.rect && containsPoint(detection.rect, point, padding)) {
+        const rectIsBounds = options.preferTopmost &&
+            Boolean(detection.mask ||
+                detection.polygon ||
+                detection.polyline ||
+                detection.orientedBox);
+        if (detection.rect &&
+            !rectIsBounds &&
+            containsPoint(detection.rect, point, padding)) {
             pushCandidate(DetectionPickTarget.Box, rectArea(detection.rect));
         }
         if (detection.polygon && pointInPolygon(point, detection.polygon.points)) {
@@ -4936,6 +5022,16 @@ function pickDetectionAtPoint(frame, point, options = {}) {
         }
     }
     candidates.sort((left, right) => {
+        if (options.preferTopmost) {
+            const layer = Number(left.result.target === DetectionPickTarget.Mask) -
+                Number(right.result.target === DetectionPickTarget.Mask);
+            if (layer !== 0)
+                return layer;
+            const order = right.zIndex - left.zIndex ||
+                right.result.detectionIndex - left.result.detectionIndex;
+            if (order !== 0)
+                return order;
+        }
         const priorityDifference = left.priority - right.priority;
         if (priorityDifference !== 0) {
             return priorityDifference;
@@ -5169,11 +5265,13 @@ function createViewportController(initial = {}) {
         screenToMedia: (point) => screenToMedia(point, transform),
         mediaToScreen: (point) => mediaToScreen(point, transform),
         setTransform(next) {
-            if (transform.locked)
-                return;
+            if (next.scale !== undefined &&
+                (!Number.isFinite(next.scale) || next.scale <= 0)) {
+                throw new RangeError("Viewport scale must be a finite number greater than zero.");
+            }
             update({
                 ...transform,
-                ...(next.scale === undefined ? {} : { scale: clampScale(next.scale) }),
+                ...(next.scale === undefined ? {} : { scale: next.scale }),
                 ...(next.x === undefined ? {} : { x: next.x }),
                 ...(next.y === undefined ? {} : { y: next.y }),
             });
@@ -5190,7 +5288,7 @@ function createViewportController(initial = {}) {
             if (transform.locked || !Number.isFinite(factor) || factor <= 0)
                 return;
             const mediaPoint = screenToMedia(point, transform);
-            const scale = clampScale(transform.scale * factor);
+            const scale = clampScale(transform.scale * factor, transform.scale);
             update({
                 ...transform,
                 scale,
@@ -5221,8 +5319,8 @@ function mediaToScreen(point, transform) {
         y: point.y * transform.scale + transform.y,
     };
 }
-function clampScale(scale) {
-    return Math.max(MIN_SCALE, Math.min(MAX_SCALE, Number.isFinite(scale) ? scale : 1));
+function clampScale(scale, current = 1) {
+    return Math.max(Math.min(MIN_SCALE, current), Math.min(Math.max(MAX_SCALE, current), Number.isFinite(scale) ? scale : 1));
 }
 function freeze(transform) {
     return Object.freeze(transform);
@@ -5311,9 +5409,9 @@ function pickAnnotationHandle(handles, point) {
     }
     return picked;
 }
-function applyAnnotationHandleDrag(detection, handle, point) {
+function applyAnnotationHandleDrag(detection, handle, point, mediaDimensions) {
     if (detection.rect && handle.kind === AnnotationHandleKind.Resize) {
-        const rect = resizeRect(detection.rect, handle.id, point);
+        const rect = resizeRect(detection.rect, handle.id, point, mediaDimensions);
         const boxRelative = detection.keypoints?.boxRelative;
         if (!detection.keypoints || !boxRelative?.some(Boolean)) {
             return { ...detection, rect };
@@ -5477,26 +5575,50 @@ function getPathHandles(points, closed, radius, hitSize) {
     }
     return handles;
 }
-function resizeRect(rect, handle, point) {
+function resizeRect(rect, handle, point, mediaDimensions) {
     let left = rect.x - rect.width / 2;
     let right = rect.x + rect.width / 2;
     let top = rect.y - rect.height / 2;
     let bottom = rect.y + rect.height / 2;
+    if (mediaDimensions) {
+        left = Math.max(0, Math.min(left, mediaDimensions.width));
+        right = Math.max(0, Math.min(right, mediaDimensions.width));
+        top = Math.max(0, Math.min(top, mediaDimensions.height));
+        bottom = Math.max(0, Math.min(bottom, mediaDimensions.height));
+    }
     if (handle.includes("w"))
-        left = Math.min(point.x, right - 5);
+        left = resizeEdge(point.x, right, -1, mediaDimensions?.width);
     if (handle.includes("e"))
-        right = Math.max(point.x, left + 5);
+        right = resizeEdge(point.x, left, 1, mediaDimensions?.width);
     if (handle.includes("n"))
-        top = Math.min(point.y, bottom - 5);
+        top = resizeEdge(point.y, bottom, -1, mediaDimensions?.height);
     if (handle.includes("s"))
-        bottom = Math.max(point.y, top + 5);
+        bottom = resizeEdge(point.y, top, 1, mediaDimensions?.height);
     return {
         x: (left + right) / 2,
         y: (top + bottom) / 2,
-        width: right - left,
-        height: bottom - top,
+        width: Math.abs(right - left),
+        height: Math.abs(bottom - top),
     };
 }
+function resizeEdge(point, anchor, initialDirection, extent) {
+    let direction = point === anchor ? initialDirection : point < anchor ? -1 : 1;
+    let minimum = 5;
+    if (extent !== undefined) {
+        const available = direction === 1 ? extent - anchor : anchor;
+        const opposite = direction === 1 ? anchor : extent - anchor;
+        // Crossing cannot push the minimum-size box past the media edge. Use the
+        // other side of the fixed anchor when it has more room.
+        if (available < Math.min(minimum, extent) && opposite > available) {
+            direction *= -1;
+        }
+        minimum = Math.min(minimum, direction === 1 ? extent - anchor : anchor);
+    }
+    const edge = direction === 1
+        ? Math.max(point, anchor + minimum)
+        : Math.min(point, anchor - minimum);
+    return extent === undefined ? edge : Math.max(0, Math.min(edge, extent));
+}
 function replacePathPoint(detection, key, index, point) {
     const geometry = detection[key];
     const points = [...geometry.points];
@@ -5553,12 +5675,10 @@ function createAnnotationEditingEngine(options = {}) {
                     setPreview(resolveBoxPreview(gesture));
                     break;
                 case "move": {
-                    const dx = input.point.x - gesture.start.point.x;
-                    const dy = input.point.y - gesture.start.point.y;
                     const moved = gesture.moved || exceedsMoveThreshold(gesture.start, input);
                     gesture = { ...gesture, current: input, moved };
                     if (moved) {
-                        const preview = offsetDetection(gesture.detection, dx, dy);
+                        const { preview, dx, dy } = resolveMovePreview(gesture, input);
                         setPreview(preview);
                         if (gesture.detection.id !== undefined) {
                             options.onFastTranslate?.(gesture.detection.id, dx, dy);
@@ -5576,7 +5696,7 @@ function createAnnotationEditingEngine(options = {}) {
                     const moved = gesture.moved || exceedsMoveThreshold(gesture.start, input);
                     gesture = { ...gesture, current: input, moved };
                     if (moved) {
-                        setPreview(applyAnnotationHandleDrag(gesture.detection, gesture.handle, input.point));
+                        setPreview(applyAnnotationHandleDrag(gesture.detection, gesture.handle, input.point, input.mediaDimensions ?? gesture.start.mediaDimensions));
                     }
                     break;
                 }
@@ -5637,7 +5757,7 @@ function createAnnotationEditingEngine(options = {}) {
                     setState(idleState());
                     return;
                 }
-                const preview = offsetDetection(active.detection, input.point.x - active.start.point.x, input.point.y - active.start.point.y);
+                const { preview } = resolveMovePreview(active, input);
                 commit(preview, active.detection);
                 return;
             }
@@ -5645,7 +5765,7 @@ function createAnnotationEditingEngine(options = {}) {
                 setState(idleState());
                 return;
             }
-            const preview = applyAnnotationHandleDrag(active.detection, active.handle, input.point);
+            const preview = applyAnnotationHandleDrag(active.detection, active.handle, input.point, input.mediaDimensions ?? active.start.mediaDimensions);
             commit(preview, active.detection);
         },
         keyDown(key) {
@@ -5656,6 +5776,18 @@ function createAnnotationEditingEngine(options = {}) {
                 commitPath();
             }
         },
+        undoCreation() {
+            if (gesture?.kind !== "path")
+                return false;
+            gesture.points.pop();
+            gesture.lastTimestamp = null;
+            const last = gesture.points.at(-1);
+            if (!last)
+                cancel();
+            else
+                setPreview(resolvePathPreview([...gesture.points, last]));
+            return true;
+        },
         beginHandleDrag(detection, handle, input) {
             if (detection.locked || detection.mask)
                 return;
@@ -5745,9 +5877,10 @@ function createAnnotationEditingEngine(options = {}) {
         const minimum = tool.minVertices ??
             (tool.geometry === AnnotationGeometryKind.Polygon ? 3 : 2);
         const closeDistance = Math.hypot(input.point.x - gesture.points[0].x, input.point.y - gesture.points[0].y) * scale();
-        const doubleClick = input.detail !== undefined
-            ? input.detail >= 2
-            : input.timestamp - gesture.lastTimestamp < CLICK_CANCEL_MS;
+        const doubleClick = gesture.lastTimestamp !== null &&
+            (input.detail !== undefined
+                ? input.detail >= 2
+                : input.timestamp - gesture.lastTimestamp < CLICK_CANCEL_MS);
         if (gesture.points.length >= minimum &&
             ((tool.geometry === AnnotationGeometryKind.Polygon &&
                 closeDistance <= CLOSE_ZONE_SCREEN_PX) ||
@@ -5777,10 +5910,13 @@ function createAnnotationEditingEngine(options = {}) {
         });
     }
     function resolveBoxPreview(active) {
-        const left = Math.min(active.start.point.x, active.current.point.x);
-        const right = Math.max(active.start.point.x, active.current.point.x);
-        const top = Math.min(active.start.point.y, active.current.point.y);
-        const bottom = Math.max(active.start.point.y, active.current.point.y);
+        const dimensions = active.current.mediaDimensions ?? active.start.mediaDimensions;
+        const start = boundPoint(active.start.point, dimensions);
+        const current = boundPoint(active.current.point, dimensions);
+        const left = Math.min(start.x, current.x);
+        const right = Math.max(start.x, current.x);
+        const top = Math.min(start.y, current.y);
+        const bottom = Math.max(start.y, current.y);
         const rect = {
             x: (left + right) / 2,
             y: (top + bottom) / 2,
@@ -5789,6 +5925,35 @@ function createAnnotationEditingEngine(options = {}) {
         };
         return tool.createDetection(rect);
     }
+    function resolveMovePreview(active, input) {
+        let dx = input.point.x - active.start.point.x;
+        let dy = input.point.y - active.start.point.y;
+        let rect = active.detection.rect;
+        const dimensions = input.mediaDimensions ?? active.start.mediaDimensions;
+        if (rect && dimensions) {
+            const width = Math.min(rect.width, dimensions.width);
+            const height = Math.min(rect.height, dimensions.height);
+            const x = Math.max(width / 2, Math.min(rect.x + dx, dimensions.width - width / 2));
+            const y = Math.max(height / 2, Math.min(rect.y + dy, dimensions.height - height / 2));
+            dx = x - rect.x;
+            dy = y - rect.y;
+            rect = { ...rect, x, y, width, height };
+        }
+        const preview = offsetDetection(active.detection, dx, dy);
+        return {
+            preview: rect && dimensions ? { ...preview, rect } : preview,
+            dx,
+            dy,
+        };
+    }
+    function boundPoint(point, dimensions) {
+        return dimensions
+            ? {
+                x: Math.max(0, Math.min(point.x, dimensions.width)),
+                y: Math.max(0, Math.min(point.y, dimensions.height)),
+            }
+            : point;
+    }
     function resolvePathPreview(points) {
         return tool.createDetection(points);
     }
@@ -6456,7 +6621,7 @@ function serializeStroke(stroke) {
     if (!stroke) {
         return "none";
     }
-    return `${stroke.color}:${stroke.alpha}:${stroke.width}`;
+    return `${stroke.color}:${stroke.alpha}:${stroke.width}${stroke.widthUnit === "screen" ? ":screen" : ""}`;
 }
 function normalizeStroke(stroke, fallbackColor) {
     if (!stroke) {
@@ -6466,6 +6631,7 @@ function normalizeStroke(stroke, fallbackColor) {
         alpha: stroke.alpha ?? DEFAULT_MASK_STROKE_ALPHA,
         color: stroke.color ?? fallbackColor,
         width: stroke.width ?? DEFAULT_MASK_STROKE_WIDTH,
+        ...(stroke.widthUnit === undefined ? {} : { widthUnit: stroke.widthUnit }),
     };
 }
 function resolveStroke(stroke, fallbackColor, mode) {
@@ -7275,6 +7441,7 @@ function resolveDefaultClassColor(detection, getClassColor) {
 const annotationRendererKinds = [
     "box",
     "box-corners",
+    "depth",
     "ellipse",
     "heatmap",
     "keypoints",
@@ -7328,6 +7495,11 @@ const RegionRendererComposeMode = {
 const annotationRenderers = {
     box: (options) => createAnnotationRenderer("box", options),
     boxCorners: (options) => createAnnotationRenderer("box-corners", options),
+    depth: (options) => ({
+        ...options,
+        id: options?.id ?? "depth",
+        kind: "depth",
+    }),
     ellipse: (options) => createAnnotationRenderer("ellipse", options),
     heatmap: (options) => ({
         ...options,
@@ -7363,6 +7535,7 @@ const annotationRendererRegistry = {
         createCanonicalStyle: createDefaultBoxCornerStyle,
         styleField: "boxCornerStyle",
     },
+    depth: { cardinality: "multiple" },
     ellipse: {
         cardinality: "singleton",
         createCanonicalStyle: createDefaultEllipseStyle,
@@ -7427,6 +7600,241 @@ function resolveAnnotationRendererStyleFields(kinds) {
     });
 }
 
+/**
+ * What the stored values of a depth map measure.
+ *
+ * Every kind stores 0 where there is no depth.
+ */
+const DepthMapKind = {
+    /** Stereo disparity in pixels of the map. Larger is nearer. */
+    DisparityPx: "disparity_px",
+    /** Metric depth along the optical axis in metres. Smaller is nearer. */
+    DepthM: "depth_m",
+    /**
+     * Unitless inverse depth up to an unknown scale and shift, as monocular
+     * models produce it. Larger is nearer; it has no metric depth.
+     */
+    RelativeInverse: "relative_inverse",
+};
+/**
+ * The quantity a depth renderer colours.
+ *
+ * Disparity is inverse depth, so it spends colour on near detail the way
+ * stereo measures it. Either way the nearest end of the range is the warm or
+ * bright end of the colour table.
+ */
+const DepthQuantity = {
+    Disparity: "disparity",
+    Depth: "depth",
+};
+const DepthColormap = {
+    Turbo: "turbo",
+    Viridis: "viridis",
+    Cividis: "cividis",
+    Inferno: "inferno",
+    Magma: "magma",
+    Grayscale: "grayscale",
+};
+/** How a depth map is sampled where one map pixel does not cover one media pixel. */
+const DepthSampling = {
+    /** Nearest when the map is at least media size, edge-aware otherwise. */
+    Auto: "auto",
+    Nearest: "nearest",
+    /**
+     * Bilinear over valid neighbours only, falling back to the nearest one
+     * across a depth edge, so objects never bleed into the background.
+     */
+    EdgeAware: "edge-aware",
+};
+/**
+ * The luma range a depth preview video's codes are written in.
+ *
+ * TV range is what browsers' hardware decoders return as written; a decoder
+ * may squeeze full range into TV range or move codes converting it to RGB.
+ */
+const DepthPreviewLevels = {
+    /** Every code from 0 to 255; the top code is 255. */
+    Full: "full",
+    /** Limited range: black is 16 and the top code is 235. */
+    Tv: "tv",
+};
+
+// Generated by tools/depth-colormaps/generate-depth-colormap-tables.py
+// from matplotlib 3.11.2. Do not edit by hand.
+//
+// Each table is 256 sRGB entries as 6-digit hex, darkest or coldest
+// first, in the order the colour coordinate t runs from 0 to 1.
+/*!
+ * Turbo, Anton Mikhailov's published table.
+ * Copyright 2019 Google LLC.
+ * SPDX-License-Identifier: Apache-2.0
+ * https://gist.github.com/mikhailov-work/ee72ba4191942acecc03fe6da94fc73f
+ */
+const turboTable = [
+    "30123b32154333184a341b51351e5836215f37246638276d392a733a2d793b2f803c32863d358b3e38913f3b973f3e9c",
+    "4040a24143a74146ac4249b1424bb5434eba4451bf4454c34456c74559cb455ccf455ed34661d64664da4666dd4669e0",
+    "466be3476ee64771e94773eb4776ee4778f0477bf2467df44680f64682f84685fa4687fb458afc458cfd448ffe4391fe",
+    "4294ff4196ff4099ff3e9bfe3d9efe3ba0fd3aa3fc38a5fb37a8fa35abf833adf731aff52fb2f42eb4f22cb7f02ab9ee",
+    "28bceb27bee925c0e723c3e422c5e220c7df1fc9dd1ecbda1ccdd81bd0d51ad2d21ad4d019d5cd18d7ca18d9c818dbc5",
+    "18ddc218dec018e0bd19e2bb19e3b91ae4b61ce6b41de7b21fe9af20eaac22ebaa25eca727eea42aefa12cf09e2ff19b",
+    "32f29835f39438f4913cf58e3ff68a43f78746f8844af8804ef97d52fa7a55fa7659fb735dfc6f61fc6c65fd6969fd66",
+    "6dfe6271fe5f75fe5c79fe597dff5680ff5384ff5188ff4e8bff4b8fff4992ff4796fe4499fe429cfe409ffd3fa1fd3d",
+    "a4fc3ca7fc3aa9fb39acfb38affa37b1f936b4f836b7f735b9f635bcf534bef434c1f334c3f134c6f034c8ef34cbed34",
+    "cdec34d0ea34d2e935d4e735d7e535d9e436dbe236dde037dfdf37e1dd37e3db38e5d938e7d739e9d539ebd339ecd13a",
+    "eecf3aefcd3af1cb3af2c93af4c73af5c53af6c33af7c13af8be39f9bc39faba39fbb838fbb637fcb336fcb136fdae35",
+    "fdac34fea933fea732fea431fea130fe9e2ffe9b2dfe992cfe962bfe932afe9029fd8d27fd8a26fc8725fc8423fb8122",
+    "fb7e21fa7b1ff9781ef9751df8721cf76f1af66c19f56918f46617f36315f26014f15d13f05b12ef5811ed5510ec530f",
+    "eb500eea4e0de84b0ce7490ce5470be4450ae2430ae14109df3f08dd3d08dc3b07da3907d83706d63506d43305d23105",
+    "d02f05ce2d04cc2b04ca2a04c82803c52603c32503c12302be2102bc2002b91e02b71d02b41b01b21a01af1801ac1701",
+    "a91601a71401a41301a112019e10019b0f01980e01950d01920b018e0a018b09028808028507028106027e05027a0403",
+].join("");
+/*!
+ * Viridis, by Stéfan van der Walt, Nathaniel Smith and Eric Firing.
+ * Released under CC0: https://github.com/BIDS/colormap
+ */
+const viridisTable = [
+    "44015444025645045745055946075a46085c460a5d460b5e470d60470e61471063471164471365481467481668481769",
+    "48186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a",
+    "472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f85",
+    "4240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b",
+    "3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d",
+    "33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e",
+    "2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e",
+    "26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d",
+    "21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f88",
+    "1fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad81",
+    "28ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc74",
+    "3fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc863",
+    "5ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d",
+    "84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32",
+    "addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21a",
+    "d8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725",
+].join("");
+/*!
+ * Cividis, Nuñez, Anderton and Renslow, PLOS ONE 13(7) e0199239 (2018),
+ * from https://github.com/pnnl/cmaputil as shipped by matplotlib.
+ * Copyright (c) 2017, Battelle Memorial Institute. Redistributed under
+ * its BSD-style licence, which asks for this notice to be kept.
+ */
+const cividisTable = [
+    "00224e00234f00245100255300255400265600275800285900285b00295d002a5f002a61002b62002c64002c66002d68",
+    "002e6a002e6c002f6d00306f0030700031700031710132710533710833700c34700f357012357014367016377018376f",
+    "1a386f1c396f1e3a6f203a6f213b6e233c6e243c6e263d6e273e6e293f6e2a3f6d2b406d2d416d2e416d2f426d31436d",
+    "32436d33446d34456c35456c36466c38476c39486c3a486c3b496c3c4a6c3d4a6c3e4b6c3f4c6c404c6c414d6c424e6c",
+    "434e6c444f6c45506c46516c47516c48526c49536c4a536c4b546c4c556c4d556c4e566c4f576c50576c51586d52596d",
+    "535a6d545a6d555b6d555c6d565c6d575d6d585e6d595e6e5a5f6e5b606e5c616e5d616e5e626e5e636f5f636f60646f",
+    "61656f62656f636670646770656870656870666970676a71686a71696b716a6c716b6d726c6d726c6e726d6f726e6f73",
+    "6f70737071737172747272747273747374757474757575757676767777767777777878777979777a7a787b7a787c7b78",
+    "7d7c787e7c787e7d787f7e78807f78817f788280798381798482798582798683798784788885788985788a86788b8778",
+    "8c88788d88788e89788f8a78908b78918b78928c78928d78938e78948e77958f779690779791779892779992779a9376",
+    "9b94769c95769d95769e96769f9775a09875a19975a29975a39a74a49b74a59c74a69c74a79d73a89e73a99f73aaa073",
+    "aba072aca172ada272aea371afa471b0a571b1a570b3a670b4a76fb5a86fb6a96fb7a96eb8aa6eb9ab6dbaac6dbbad6d",
+    "bcae6cbdae6cbeaf6bbfb06bc0b16ac1b26ac2b369c3b369c4b468c5b568c6b667c7b767c8b866c9b965cbb965ccba64",
+    "cdbb63cebc63cfbd62d0be62d1bf61d2c060d3c05fd4c15fd5c25ed6c35dd7c45cd9c55cdac65bdbc75adcc859ddc858",
+    "dec958dfca57e0cb56e1cc55e2cd54e4ce53e5cf52e6d051e7d150e8d24fe9d34eead34cebd44bedd54aeed649efd748",
+    "f0d846f1d945f2da44f3db42f5dc41f6dd3ff7de3ef8df3cf9e03afbe138fce236fde334fee434fee535fee636fee838",
+].join("");
+/*!
+ * Inferno, by Stéfan van der Walt and Nathaniel Smith.
+ * Released under CC0: https://github.com/BIDS/colormap
+ */
+const infernoTable = [
+    "00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a0722",
+    "0b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48",
+    "210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b0964",
+    "3d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d",
+    "57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e",
+    "71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a",
+    "8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62",
+    "a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655",
+    "bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545",
+    "d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933",
+    "e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711f",
+    "f1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0a",
+    "f98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0f",
+    "fcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932",
+    "f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865",
+    "f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4",
+].join("");
+/*!
+ * Magma, by Stéfan van der Walt and Nathaniel Smith.
+ * Released under CC0: https://github.com/BIDS/colormap
+ */
+const magmaTable = [
+    "00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e090720",
+    "0a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c1044",
+    "1d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f1163311165331067341069",
+    "36106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b",
+    "51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c81",
+    "6a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e2482802582812581",
+    "8326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f",
+    "9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367a",
+    "b73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070",
+    "d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064",
+    "e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695c",
+    "f56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761",
+    "fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571",
+    "fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287",
+    "fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1",
+    "fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf",
+].join("");
+
+const DEPTH_COLORMAP_ENTRIES = 256;
+const colormapTables = {
+    cividis: cividisTable,
+    inferno: infernoTable,
+    magma: magmaTable,
+    turbo: turboTable,
+    viridis: viridisTable,
+};
+const depthColormaps = new Set(Object.values(DepthColormap));
+function isDepthColormap(value) {
+    return typeof value === "string" && depthColormaps.has(value);
+}
+/**
+ * The colour table as 256 RGBA8 entries with opaque alpha, far or low values
+ * first. Entry `i` is the colour of `t = i / 255`.
+ */
+function createDepthColormapLut(name) {
+    if (!isDepthColormap(name)) {
+        throw new RangeError(`Unknown depth colormap "${String(name)}".`);
+    }
+    const lut = new Uint8Array(DEPTH_COLORMAP_ENTRIES * 4);
+    for (let index = 0; index < DEPTH_COLORMAP_ENTRIES; index += 1) {
+        const offset = index * 4;
+        if (name === DepthColormap.Grayscale) {
+            lut[offset] = index;
+            lut[offset + 1] = index;
+            lut[offset + 2] = index;
+        }
+        else {
+            const table = colormapTables[name];
+            const hex = index * 6;
+            lut[offset] = Number.parseInt(table.slice(hex, hex + 2), 16);
+            lut[offset + 1] = Number.parseInt(table.slice(hex + 2, hex + 4), 16);
+            lut[offset + 2] = Number.parseInt(table.slice(hex + 4, hex + 6), 16);
+        }
+        lut[offset + 3] = 255;
+    }
+    return lut;
+}
+/**
+ * CSS colours of a depth colormap at `stops` evenly spaced points, far end
+ * first and near end last, read from the same table the depth renderer draws
+ * with. A legend that matches the picture is
+ * `linear-gradient(to right, ${colors.join(", ")})`.
+ */
+function depthColormapColors(colormap, stops = 16) {
+    if (!Number.isInteger(stops) || stops < 2 || stops > DEPTH_COLORMAP_ENTRIES) {
+        throw new RangeError(`Depth colormap stops must be an integer from 2 to ${DEPTH_COLORMAP_ENTRIES}, got ${stops}.`);
+    }
+    const lut = createDepthColormapLut(colormap);
+    return Array.from({ length: stops }, (_, stop) => {
+        const offset = Math.round((stop * (DEPTH_COLORMAP_ENTRIES - 1)) / (stops - 1)) * 4;
+        return `#${Array.from(lut.subarray(offset, offset + 3), (channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+    });
+}
+
 /**
  * Resolves built-in renderer descriptors into the existing specialized style
  * fields. The browser backend deliberately keeps ownership of its box, mask,
@@ -7458,6 +7866,9 @@ function resolveAnnotationRendererPresentation(presentation) {
         if (renderer.kind === "heatmap") {
             validateHeatmapRenderer(renderer);
         }
+        if (renderer.kind === "depth") {
+            validateDepthRenderer(renderer);
+        }
         if (rendererIds.has(renderer.id)) {
             throw new RangeError(`MediaRendererPresentation.renderers contains duplicate renderer id "${renderer.id}".`);
         }
@@ -7500,6 +7911,32 @@ function validateHeatmapRenderer(renderer) {
         throw new RangeError(`Invalid heatmap renderer settings for "${renderer.id}".`);
     }
 }
+const depthQuantities = new Set(Object.values(DepthQuantity));
+const depthSamplings = new Set(Object.values(DepthSampling));
+function validateDepthRenderer(renderer) {
+    const { colormap, noDepthColor, opacity, quantity, range, sampling, wipe } = renderer;
+    if ((colormap !== undefined && !isDepthColormap(colormap)) ||
+        (quantity !== undefined && !depthQuantities.has(quantity)) ||
+        (sampling !== undefined && !depthSamplings.has(sampling)) ||
+        (range !== undefined &&
+            range !== "clip" &&
+            range !== "auto" &&
+            (typeof range !== "object" ||
+                range === null ||
+                !Number.isFinite(range.min) ||
+                !Number.isFinite(range.max) ||
+                range.min >= range.max)) ||
+        (opacity !== undefined && !Number.isFinite(opacity)) ||
+        (wipe !== undefined &&
+            !(Number.isFinite(wipe) && wipe >= 0 && wipe <= 1)) ||
+        (noDepthColor !== undefined &&
+            noDepthColor !== null &&
+            !(Number.isInteger(noDepthColor) &&
+                noDepthColor >= 0 &&
+                noDepthColor <= 0xffffff))) {
+        throw new RangeError(`Invalid depth renderer settings for "${renderer.id}".`);
+    }
+}
 function isStyleBackedAnnotationRenderer(renderer) {
     return isStyleBackedAnnotationRendererKind(renderer.kind);
 }
@@ -7955,8 +8392,10 @@ function createIdMaskFrame(instructions, options = {}) {
     if (instructions.length === 0) {
         return undefined;
     }
-    const maskWidth = Math.max(...instructions.map(({ mask }) => mask.width));
-    const maskHeight = Math.max(...instructions.map(({ mask }) => mask.height));
+    /* Pixel-grid dimensions use integer parts throughout allocation and RLE
+       traversal. */
+    const maskWidth = Math.floor(Math.max(...instructions.map(({ mask }) => mask.width)));
+    const maskHeight = Math.floor(Math.max(...instructions.map(({ mask }) => mask.height)));
     const width = resolveRasterWidth(maskWidth, options.maxWidth);
     const height = width === maskWidth
         ? maskHeight
@@ -8008,8 +8447,8 @@ function createIdMaskFrame(instructions, options = {}) {
  */
 function writeMaskRuns(data, frameWidth, mask, detectionMaskId) {
     const counts = decodeCompressedRleCounts(mask.counts);
-    const maskWidth = mask.width;
-    const maskHeight = mask.height;
+    const maskWidth = Math.floor(mask.width);
+    const maskHeight = Math.floor(mask.height);
     let maskOffset = 0;
     for (let index = 0; index < counts.length; index += 1) {
         const runLength = counts[index] ?? 0;
@@ -8043,9 +8482,10 @@ function writeMaskRuns(data, frameWidth, mask, detectionMaskId) {
  */
 function writeScaledMaskRuns(data, axes, mask, detectionMaskId) {
     const counts = decodeCompressedRleCounts(mask.counts);
-    const maskWidth = mask.width;
-    const maskHeight = mask.height;
+    const maskWidth = Math.floor(mask.width);
+    const maskHeight = Math.floor(mask.height);
     let maskOffset = 0;
+    const stride = axes.stride;
     for (let index = 0; index < counts.length; index += 1) {
         const runLength = counts[index] ?? 0;
         if (index % 2 === 0 || runLength <= 0) {
@@ -8054,17 +8494,30 @@ function writeScaledMaskRuns(data, axes, mask, detectionMaskId) {
         }
         let x = Math.floor(maskOffset / maskHeight);
         let y = maskOffset - x * maskHeight;
-        let column = axes.columns[x];
-        for (let step = 0; step < runLength; step += 1) {
-            if (x >= maskWidth) {
-                break;
-            }
-            data[axes.rows[y] + column] = detectionMaskId;
-            y += 1;
+        let remaining = runLength;
+        /* A run walks down one column and wraps into the next, so it splits into
+           column-sized segments. Within a segment the destination offset only ever
+           steps by the row pitch or stays put: createMaskAxisMap builds
+           `rows[i] = min(height - 1, floor(i * scale)) * width` with scale <= 1, so
+           consecutive entries differ by exactly 0 or exactly `width`. Walking the
+           destination directly therefore touches the same bytes the per-pixel loop
+           touched, and drops the bounds test, the wrap test and one typed-array
+           load from every source pixel. Where the scale collapses several source
+           rows onto one destination row, this writes that byte once instead of
+           once per source row. */
+        while (remaining > 0 && x < maskWidth) {
+            const span = Math.min(remaining, maskHeight - y);
+            const column = axes.columns[x];
+            const first = axes.rows[y];
+            const last = axes.rows[y + span - 1];
+            for (let offset = first; offset <= last; offset += stride) {
+                data[offset + column] = detectionMaskId;
+            }
+            remaining -= span;
+            y += span;
             if (y === maskHeight) {
                 y = 0;
                 x += 1;
-                column = axes.columns[x];
             }
         }
         maskOffset += runLength;
@@ -8076,22 +8529,19 @@ function resolveRasterWidth(maskWidth, maxWidth) {
         : maskWidth;
 }
 /**
- * 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. 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.
+ * Converts a source-grid stroke width into raster texels. Fractional widths
+ * let coverage shaders draw a border within a texel. The ceiling bounds the
+ * neighbourhood the shaders scan.
  */
 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);
+    return Math.min(strokeWidth * scale, MAX_ID_MASK_STROKE_WIDTH);
 }
 function createScaledMaskAxes(frame) {
     return {
         columns: createMaskAxisMap(frame.maskWidth, frame.width, 1),
         rows: createMaskAxisMap(frame.maskHeight, frame.height, frame.width),
+        stride: frame.width,
     };
 }
 /** Rows hold their destination offset, so writing a run is two lookups. */
@@ -8320,6 +8770,658 @@ function includes(values, value) {
         : values.has(value);
 }
 
+const DEPTH_MANIFEST_SCHEMA = "supervision.depth-manifest";
+const PREVIEW_TOP_CODES = {
+    full: 255,
+    tv: 235,
+};
+/**
+ * TV black, 16, is written for no depth, and a decoder that converts to RGB
+ * returns every code below it as black too, so the reserved band must cover it.
+ */
+const PREVIEW_MIN_RESERVED_CODES = { full: 0, tv: 16 };
+const depthPreviewLevels = new Set(Object.values(DepthPreviewLevels));
+const depthMapKinds = new Set(Object.values(DepthMapKind));
+const FRAME_INDEX_TOKEN = /\{index(?::0(\d{1,2}))?\}/g;
+/**
+ * Reads the snake_case `depth.json` a producer writes into a
+ * {@link DepthManifest}, and rejects anything a renderer could not honour.
+ *
+ * Messages name the offending wire field, such as
+ * `depth.json: storage.scale must be a positive number`. Unknown fields are
+ * ignored so newer producers stay readable.
+ */
+function parseDepthManifest(json) {
+    const root = readObject(json, "the manifest");
+    if (root.schema !== DEPTH_MANIFEST_SCHEMA) {
+        fail(`schema must be "${DEPTH_MANIFEST_SCHEMA}"`);
+    }
+    if (root.version !== 1) {
+        fail(`version ${String(root.version)} is not supported; expected 1`);
+    }
+    const kind = root.kind;
+    if (typeof kind !== "string" || !depthMapKinds.has(kind)) {
+        fail(`kind must be one of ${[...depthMapKinds].join(", ")}`);
+    }
+    const depthKind = kind;
+    const width = readPositiveInteger(root.width, "width");
+    const height = readPositiveInteger(root.height, "height");
+    const view = readOptionalString(root.view, "view");
+    const storage = readObject(root.storage, "storage");
+    if (storage.format !== "png16") {
+        fail('storage.format must be "png16"');
+    }
+    const scale = readPositiveNumber(storage.scale, "storage.scale");
+    if (storage.no_depth !== 0) {
+        fail("storage.no_depth must be 0");
+    }
+    const camera = root.camera === undefined || root.camera === null
+        ? undefined
+        : readCamera(root.camera);
+    const displayRange = readDisplayRange(root, depthKind);
+    const hasImage = root.image !== undefined && root.image !== null;
+    const hasFrames = root.frames !== undefined && root.frames !== null;
+    if (hasImage === hasFrames) {
+        fail("exactly one of image or frames must be present");
+    }
+    const image = hasImage ? readImage(root.image) : undefined;
+    const frames = hasFrames ? readFrames(root.frames) : undefined;
+    let preview;
+    if (root.preview !== undefined && root.preview !== null) {
+        if (!frames) {
+            fail("preview is only valid next to frames");
+        }
+        if (depthKind !== DepthMapKind.DisparityPx) {
+            fail(`preview is only supported for kind ${DepthMapKind.DisparityPx}`);
+        }
+        preview = readPreview(root.preview);
+    }
+    return {
+        schema: DEPTH_MANIFEST_SCHEMA,
+        version: 1,
+        kind: depthKind,
+        ...(view === undefined ? {} : { view }),
+        width,
+        height,
+        storage: { format: "png16", noDepth: 0, scale },
+        ...(camera === undefined ? {} : { camera }),
+        ...(displayRange === undefined ? {} : { displayRange }),
+        ...(image === undefined ? {} : { image }),
+        ...(frames === undefined ? {} : { frames }),
+        ...(preview === undefined ? {} : { preview }),
+    };
+}
+/**
+ * Expands a clip frame pattern for one frame index: `{index}` becomes the
+ * plain number and `{index:06}` the number zero-padded to six digits.
+ */
+function resolveDepthFrameFile(pattern, index) {
+    if (!Number.isInteger(index) || index < 0) {
+        throw new RangeError(`Depth frame index must be a non-negative integer, got ${index}.`);
+    }
+    return pattern.replace(FRAME_INDEX_TOKEN, (_token, width) => width === undefined
+        ? String(index)
+        : String(index).padStart(Number(width), "0"));
+}
+/**
+ * Checks a host-supplied depth map's shape, without reading its sample values.
+ */
+function validateDepthMap(map) {
+    const reject = (message) => {
+        throw new RangeError(`DepthMap ${message}.`);
+    };
+    if (!depthMapKinds.has(map.kind)) {
+        reject(`kind must be one of ${[...depthMapKinds].join(", ")}`);
+    }
+    if (!isPositiveInteger(map.width) || !isPositiveInteger(map.height)) {
+        reject("width and height must be positive integers");
+    }
+    const pixelCount = map.width * map.height;
+    const samples = map.samples;
+    if (samples?.encoding === "scaled16") {
+        if (!(samples.values instanceof Uint16Array)) {
+            reject("samples.values must be a Uint16Array for scaled16 samples");
+        }
+        if (!isPositiveNumber(samples.scale)) {
+            reject("samples.scale must be a positive number");
+        }
+    }
+    else if (samples?.encoding === "preview8") {
+        if (!(samples.values instanceof Uint8Array)) {
+            reject("samples.values must be a Uint8Array for preview8 samples");
+        }
+        const levels = samples.levels ?? DepthPreviewLevels.Full;
+        if (!depthPreviewLevels.has(levels)) {
+            reject(`samples.levels must be one of ${[...depthPreviewLevels].join(", ")}`);
+        }
+        if (!isReservedPreviewCode(samples.reservedMax, levels)) {
+            reject(`samples.reservedMax must be ${describeReservedCodes(levels)}`);
+        }
+        if (!isRange(samples.range)) {
+            reject("samples.range must have finite bounds with min < max");
+        }
+    }
+    else {
+        reject('samples.encoding must be "scaled16" or "preview8"');
+    }
+    if (samples.values.length !== pixelCount) {
+        reject(`samples.values has ${samples.values.length} values for ${map.width}x${map.height} pixels`);
+    }
+    if (map.camera !== undefined && !isCamera(map.camera)) {
+        reject("camera needs finite fxPx and baselineM above 0, and finite optional offsets");
+    }
+    if (map.displayRange !== undefined && !isRange(map.displayRange)) {
+        reject("displayRange must have finite bounds with min < max");
+    }
+    if (map.confidence !== undefined) {
+        if (!(map.confidence instanceof Uint8Array)) {
+            reject("confidence must be a Uint8Array");
+        }
+        if (map.confidence.length !== pixelCount) {
+            reject(`confidence has ${map.confidence.length} values for ${map.width}x${map.height} pixels`);
+        }
+    }
+}
+function readCamera(value) {
+    const camera = readObject(value, "camera");
+    const fxPx = readPositiveNumber(camera.fx_px, "camera.fx_px");
+    const baselineM = readPositiveNumber(camera.baseline_m, "camera.baseline_m");
+    const doffsPx = readOptionalFinite(camera.doffs_px, "camera.doffs_px");
+    const cxPx = readOptionalFinite(camera.cx_px, "camera.cx_px");
+    const cyPx = readOptionalFinite(camera.cy_px, "camera.cy_px");
+    return {
+        fxPx,
+        baselineM,
+        ...(doffsPx === undefined ? {} : { doffsPx }),
+        ...(cxPx === undefined ? {} : { cxPx }),
+        ...(cyPx === undefined ? {} : { cyPx }),
+    };
+}
+/**
+ * `display_range` is in the kind's unit; `display_range_px` is its name for
+ * disparity, kept because disparity producers already write it.
+ */
+function readDisplayRange(root, kind) {
+    const inKindUnit = readOptionalRange(root.display_range, "display_range");
+    const inPixels = readOptionalRange(root.display_range_px, "display_range_px");
+    if (inPixels !== undefined && kind !== DepthMapKind.DisparityPx) {
+        fail(`display_range_px is only valid for kind ${DepthMapKind.DisparityPx}; use display_range`);
+    }
+    if (inKindUnit !== undefined &&
+        inPixels !== undefined &&
+        (inKindUnit.min !== inPixels.min || inKindUnit.max !== inPixels.max)) {
+        fail("display_range and display_range_px disagree");
+    }
+    return inKindUnit ?? inPixels;
+}
+function readImage(value) {
+    const image = readObject(value, "image");
+    const file = readFileName(image.file, "image.file");
+    const confidenceFile = readOptionalFileName(image.confidence_file, "image.confidence_file");
+    return {
+        file,
+        ...(confidenceFile === undefined ? {} : { confidenceFile }),
+    };
+}
+function readFrames(value) {
+    const frames = readObject(value, "frames");
+    const count = readPositiveInteger(frames.count, "frames.count");
+    const exact = readFramePattern(frames.exact, "frames.exact");
+    const confidence = frames.confidence === undefined || frames.confidence === null
+        ? undefined
+        : readFramePattern(frames.confidence, "frames.confidence");
+    const timesS = frames.times_s === undefined || frames.times_s === null
+        ? undefined
+        : readFrameTimes(frames.times_s, count);
+    return {
+        count,
+        exact,
+        ...(confidence === undefined ? {} : { confidence }),
+        ...(timesS === undefined ? {} : { timesS }),
+    };
+}
+function readFrameTimes(value, count) {
+    if (!Array.isArray(value) || value.length !== count) {
+        fail(`frames.times_s must be an array of frames.count (${count}) times`);
+    }
+    const times = value;
+    times.forEach((time, index) => {
+        if (typeof time !== "number" || !Number.isFinite(time) || time < 0) {
+            fail(`frames.times_s[${index}] must be a finite number of seconds >= 0`);
+        }
+        if (index > 0 && time <= times[index - 1]) {
+            fail(`frames.times_s must strictly increase at index ${index}`);
+        }
+    });
+    return [...times];
+}
+/** A preview without `levels` predates TV range and is read as full range. */
+function readPreview(value) {
+    const preview = readObject(value, "preview");
+    const file = readFileName(preview.file, "preview.file");
+    const codec = readOptionalString(preview.codec, "preview.codec");
+    const levels = preview.levels ?? DepthPreviewLevels.Full;
+    const reservedMax = preview.reserved_max;
+    if (typeof levels !== "string" || !depthPreviewLevels.has(levels)) {
+        fail(`preview.levels must be one of ${[...depthPreviewLevels].join(", ")}`);
+    }
+    const previewLevels = levels;
+    if (!isReservedPreviewCode(reservedMax, previewLevels)) {
+        fail(`preview.reserved_max must be ${describeReservedCodes(previewLevels)}`);
+    }
+    const range = readOptionalRange(preview.range_px, "preview.range_px");
+    if (range === undefined) {
+        fail("preview.range_px is required");
+    }
+    return {
+        file,
+        ...(codec === undefined ? {} : { codec }),
+        levels: previewLevels,
+        reservedMax,
+        range,
+    };
+}
+/** The code that stands for the top of a preview's range: 255, or 235 in TV range. */
+function depthPreviewTopCode(levels = "full") {
+    return PREVIEW_TOP_CODES[levels];
+}
+function readFramePattern(value, path) {
+    const pattern = readFileName(value, path);
+    if (!new RegExp(FRAME_INDEX_TOKEN.source).test(pattern)) {
+        fail(`${path} must contain {index} or a padded {index:06}`);
+    }
+    return pattern;
+}
+function readOptionalRange(value, path) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value) ||
+        value.length !== 2 ||
+        !value.every((bound) => typeof bound === "number" && Number.isFinite(bound))) {
+        fail(`${path} must be two finite numbers [low, high]`);
+    }
+    const [min, max] = value;
+    if (!(min < max)) {
+        fail(`${path} must have low < high`);
+    }
+    return { min, max };
+}
+function readObject(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        fail(`${path} must be an object`);
+    }
+    return value;
+}
+function readPositiveInteger(value, path) {
+    if (!isPositiveInteger(value)) {
+        fail(`${path} must be a positive integer`);
+    }
+    return value;
+}
+function readPositiveNumber(value, path) {
+    if (!isPositiveNumber(value)) {
+        fail(`${path} must be a positive number`);
+    }
+    return value;
+}
+function readOptionalFinite(value, path) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        fail(`${path} must be a finite number`);
+    }
+    return value;
+}
+function readOptionalString(value, path) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        fail(`${path} must be a string`);
+    }
+    return value;
+}
+function readFileName(value, path) {
+    if (typeof value !== "string" || value.length === 0) {
+        fail(`${path} must be a non-empty file name`);
+    }
+    return value;
+}
+function readOptionalFileName(value, path) {
+    return value === undefined || value === null
+        ? undefined
+        : readFileName(value, path);
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+/** At least two valid codes must remain, or the preview span is zero. */
+function isReservedPreviewCode(value, levels) {
+    return (typeof value === "number" &&
+        Number.isInteger(value) &&
+        value >= PREVIEW_MIN_RESERVED_CODES[levels] &&
+        value <= PREVIEW_TOP_CODES[levels] - 2);
+}
+function describeReservedCodes(levels) {
+    return `an integer from ${PREVIEW_MIN_RESERVED_CODES[levels]} to ${PREVIEW_TOP_CODES[levels] - 2} at ${levels} levels`;
+}
+function isRange(range) {
+    return (range !== undefined &&
+        Number.isFinite(range.min) &&
+        Number.isFinite(range.max) &&
+        range.min < range.max);
+}
+function isCamera(camera) {
+    return (isPositiveNumber(camera.fxPx) &&
+        isPositiveNumber(camera.baselineM) &&
+        [camera.doffsPx, camera.cxPx, camera.cyPx].every((value) => value === undefined || Number.isFinite(value)));
+}
+function fail(message) {
+    throw new RangeError(`depth.json: ${message}`);
+}
+
+/** Percentiles `"auto"` colours between: outliers and flying pixels fall outside. */
+const DEFAULT_DEPTH_PERCENTILE_LOW = 0.02;
+const DEFAULT_DEPTH_PERCENTILE_HIGH = 0.98;
+/** Below this share of valid samples a percentile says nothing about the scene. */
+const MIN_VALID_SAMPLE_SHARE = 0.01;
+const PERCENTILE_SAMPLE_STRIDE = 2;
+const FALLBACK_RANGE = { min: 0, max: 1 };
+/**
+ * Metric depth needs a camera to come out of disparity, and relative inverse
+ * depth has no metric depth at all, so both fall back to disparity.
+ */
+function resolveDepthQuantity(kind, quantity = DepthQuantity.Disparity, camera) {
+    if (quantity === DepthQuantity.Disparity) {
+        return { fellBack: false, quantity };
+    }
+    if (kind === DepthMapKind.DepthM ||
+        (kind === DepthMapKind.DisparityPx && camera !== undefined)) {
+        return { fellBack: false, quantity: DepthQuantity.Depth };
+    }
+    return { fellBack: true, quantity: DepthQuantity.Disparity };
+}
+function resolveDepthValueConversion(map, quantity) {
+    const resolved = resolveDepthQuantity(map.kind, quantity, map.camera);
+    const nearIsLow = resolved.quantity === DepthQuantity.Depth;
+    const identity = {
+        ...resolved,
+        innerOffset: 0,
+        nearIsLow,
+        numerator: 1,
+        outerOffset: 0,
+        reciprocal: false,
+    };
+    const camera = map.camera;
+    const focalBaseline = camera ? camera.fxPx * camera.baselineM : 1;
+    const doffs = camera?.doffsPx ?? 0;
+    if (map.kind === DepthMapKind.DisparityPx &&
+        resolved.quantity === DepthQuantity.Depth) {
+        // Z = fx * B / (d + doffs)
+        return {
+            ...identity,
+            innerOffset: doffs,
+            numerator: focalBaseline,
+            reciprocal: true,
+        };
+    }
+    if (map.kind === DepthMapKind.DepthM &&
+        resolved.quantity === DepthQuantity.Disparity) {
+        // d = fx * B / Z - doffs, or plain inverse depth without a camera.
+        return {
+            ...identity,
+            numerator: focalBaseline,
+            outerOffset: doffs === 0 ? 0 : -doffs,
+            reciprocal: true,
+        };
+    }
+    return identity;
+}
+function convertDepthValue(value, conversion) {
+    return conversion.reciprocal
+        ? conversion.numerator / (value + conversion.innerOffset) +
+            conversion.outerOffset
+        : value;
+}
+/**
+ * Converts a range in the map kind's unit, swapping its bounds under a
+ * reciprocal. Null when a bound has no image, such as disparity at or below
+ * `-doffsPx` for depth, which would be infinite or negative.
+ */
+function convertDepthRange(range, conversion) {
+    if (!hasConvertedValue(Math.min(range.min, range.max), conversion)) {
+        return null;
+    }
+    const first = convertDepthValue(range.min, conversion);
+    const second = convertDepthValue(range.max, conversion);
+    const min = Math.min(first, second);
+    const max = Math.max(first, second);
+    return Number.isFinite(min) && Number.isFinite(max) && min < max
+        ? { max, min }
+        : null;
+}
+/** The value in the map kind's unit, or null where there is no depth. */
+function decodeDepthSample(stored, samples) {
+    if (samples.encoding === "scaled16") {
+        return stored === 0 ? null : stored / samples.scale;
+    }
+    if (stored <= samples.reservedMax) {
+        return null;
+    }
+    const span = depthPreviewSpan(samples);
+    return (samples.range.min +
+        (Math.min(stored - samples.reservedMax - 1, span) / span) *
+            (samples.range.max - samples.range.min));
+}
+/**
+ * Steps between the lowest valid preview code and the top one, so one step
+ * is `(range.max - range.min) / span`.
+ */
+function depthPreviewSpan(samples) {
+    return depthPreviewTopCode(samples.levels) - samples.reservedMax - 1;
+}
+/**
+ * This map's own percentile range in the coloured quantity's unit, or null
+ * when fewer than 1 % of the samples it reads hold depth.
+ *
+ * It depends on this map alone, so a frame always gets the same range. Pass
+ * the result back as an explicit range to keep colours steady across frames.
+ */
+function computeDepthPercentileRange(map, options = {}) {
+    const low = options.low ?? DEFAULT_DEPTH_PERCENTILE_LOW;
+    const high = options.high ?? DEFAULT_DEPTH_PERCENTILE_HIGH;
+    if (!Number.isFinite(low) ||
+        !Number.isFinite(high) ||
+        low < 0 ||
+        high > 1 ||
+        low >= high) {
+        throw new RangeError("Depth percentiles need 0 <= low < high <= 1, as fractions.");
+    }
+    const conversion = resolveDepthValueConversion(map, options.quantity);
+    const histogram = histogramDepthCodes(map, conversion);
+    if (histogram.valid < histogram.sampled * MIN_VALID_SAMPLE_SHARE) {
+        return null;
+    }
+    return rangeFromHistogram(map, histogram, low, high, conversion);
+}
+/**
+ * The range a renderer colours between, in the coloured quantity's unit.
+ *
+ * `autoRange` lets a caller that already computed this map's percentile range
+ * skip the histogram. A range that cannot be honoured falls back step by step:
+ * the display range to the percentile range, and that to the full range of
+ * the valid samples, so a sparse frame still colours what it has.
+ */
+function resolveDepthDisplayRange(map, options, conversion, autoRange) {
+    const range = options.range ?? "clip";
+    if (typeof range === "object") {
+        return range;
+    }
+    if (range === "clip" && map.displayRange) {
+        const clip = convertDepthRange(map.displayRange, conversion);
+        if (clip) {
+            return clip;
+        }
+    }
+    const percentile = autoRange !== undefined
+        ? autoRange
+        : computeDepthPercentileRange(map, { quantity: conversion.quantity });
+    if (percentile) {
+        return percentile;
+    }
+    const histogram = histogramDepthCodes(map, conversion);
+    return histogram.valid > 0
+        ? rangeFromHistogram(map, histogram, 0, 1, conversion)
+        : FALLBACK_RANGE;
+}
+/** Resolves a renderer's quantity and range for one map into shader terms. */
+function resolveDepthColorMapping(map, options = {}, autoRange) {
+    const conversion = resolveDepthValueConversion(map, options.quantity);
+    const range = resolveDepthDisplayRange(map, options, conversion, autoRange);
+    return { ...conversion, hi: range.max, lo: range.min };
+}
+function histogramDepthCodes(map, conversion) {
+    const { samples } = map;
+    const values = samples.values;
+    const counts = new Uint32Array(samples.encoding === "scaled16" ? 65_536 : 256);
+    let firstValid = samples.encoding === "scaled16" ? 1 : samples.reservedMax + 1;
+    // Decoded values never fall as codes rise, so the codes the conversion
+    // gives a value for start at one code.
+    while (firstValid < counts.length &&
+        !hasConvertedValue(decodeDepthSample(firstValid, samples), conversion)) {
+        firstValid += 1;
+    }
+    let sampled = 0;
+    let valid = 0;
+    for (let y = 0; y < map.height; y += PERCENTILE_SAMPLE_STRIDE) {
+        const row = y * map.width;
+        for (let x = 0; x < map.width; x += PERCENTILE_SAMPLE_STRIDE) {
+            const code = values[row + x];
+            sampled += 1;
+            if (code >= firstValid) {
+                counts[code] += 1;
+                valid += 1;
+            }
+        }
+    }
+    return { counts, sampled, valid };
+}
+/**
+ * Exact percentiles over the stored codes, taken by nearest rank and then
+ * mapped through the monotonic conversion to the coloured quantity. A frame
+ * whose chosen codes coincide, preview codes above the top one counting as
+ * the top one, is widened by one code, so the range stays usable as an
+ * explicit range.
+ */
+function rangeFromHistogram(map, histogram, low, high, conversion) {
+    const topCode = map.samples.encoding === "scaled16"
+        ? histogram.counts.length - 1
+        : depthPreviewTopCode(map.samples.levels);
+    const lastRank = histogram.valid - 1;
+    let lowCode = Math.min(topCode, codeAtRank(histogram.counts, Math.round(low * lastRank)));
+    let highCode = Math.min(topCode, codeAtRank(histogram.counts, Math.round(high * lastRank)));
+    if (lowCode === highCode) {
+        if (highCode < topCode)
+            highCode += 1;
+        else
+            lowCode -= 1;
+    }
+    const lowValue = decodeDepthSample(lowCode, map.samples) ?? 0;
+    const highValue = decodeDepthSample(highCode, map.samples) ?? 0;
+    return (convertDepthRange({ max: highValue, min: lowValue }, conversion) ??
+        FALLBACK_RANGE);
+}
+/**
+ * Whether `value` converts to the coloured quantity: depth from disparity at
+ * or below `-doffsPx` would be infinite or negative, and `readDepthAt` gives
+ * it none.
+ */
+function hasConvertedValue(value, conversion) {
+    return !conversion.reciprocal || value + conversion.innerOffset > 0;
+}
+function codeAtRank(counts, rank) {
+    let seen = 0;
+    for (let code = 0; code < counts.length; code += 1) {
+        seen += counts[code];
+        if (seen > rank) {
+            return code;
+        }
+    }
+    return counts.length - 1;
+}
+
+/**
+ * Reads the depth map pixel under a point.
+ *
+ * `coordinateSpace` is the size `point` is measured in, normally the media's;
+ * the map is stretched over it the way the renderer draws it. Without it the
+ * point is in map pixels. Returns null outside the map.
+ */
+function readDepthAt(map, point, coordinateSpace) {
+    const scaleX = coordinateSpace ? map.width / coordinateSpace.width : 1;
+    const scaleY = coordinateSpace ? map.height / coordinateSpace.height : 1;
+    const x = Math.floor(point.x * scaleX);
+    const y = Math.floor(point.y * scaleY);
+    if (!Number.isFinite(x) ||
+        !Number.isFinite(y) ||
+        x < 0 ||
+        y < 0 ||
+        x >= map.width ||
+        y >= map.height) {
+        return null;
+    }
+    const index = y * map.width + x;
+    const { samples } = map;
+    const stored = samples.values[index];
+    const value = decodeDepthSample(stored, samples);
+    const step = samples.encoding === "scaled16"
+        ? 1 / samples.scale
+        : (samples.range.max - samples.range.min) / depthPreviewSpan(samples);
+    const confidence = map.confidence?.[index];
+    const readout = {
+        precision: samples.encoding === "scaled16" ? "exact" : "preview",
+        step,
+        stored,
+        valid: value !== null,
+        x,
+        y,
+        ...(confidence === undefined ? {} : { confidence: confidence / 255 }),
+    };
+    if (value === null) {
+        return readout;
+    }
+    const camera = map.camera;
+    const focalBaseline = camera ? camera.fxPx * camera.baselineM : undefined;
+    const doffs = camera?.doffsPx ?? 0;
+    switch (map.kind) {
+        case DepthMapKind.DisparityPx: {
+            const shifted = value + doffs;
+            return {
+                ...readout,
+                disparityPx: value,
+                ...(focalBaseline !== undefined && shifted > 0
+                    ? { depthM: focalBaseline / shifted }
+                    : {}),
+            };
+        }
+        case DepthMapKind.DepthM:
+            return {
+                ...readout,
+                depthM: value,
+                ...(focalBaseline !== undefined
+                    ? { disparityPx: focalBaseline / value - doffs }
+                    : {}),
+            };
+        default:
+            return { ...readout, relativeInverse: value };
+    }
+}
+
 var MediaRendererFit;
 (function (MediaRendererFit) {
     /**
@@ -8481,5 +9583,5 @@ var MediaSessionActivityStatus;
     MediaSessionActivityStatus["Waiting"] = "waiting";
 })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));
 
-export { AnnotationFrameMutationKind, AnnotationGeometryKind, AnnotationGestureStateKind, AnnotationHandleKind, BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BaseOrientedBoxStyle, BasePercentageBarStyle, 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, PercentageBarPlacement, 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 };
+export { AnnotationFrameMutationKind, AnnotationGeometryKind, AnnotationGestureStateKind, AnnotationHandleKind, BaseBoxCornerStyle, BaseBoxStyle, BaseFocusStyle, BaseInteractionStyle, BaseKeypointStyle, BaseLabelStyle, BaseMarkerStyle, BaseMaskStyle, BaseOrientedBoxStyle, BasePercentageBarStyle, BasePolygonStyle, BasePolylineStyle, BoxShape, StrokeAlignment as BoxStrokeAlignment, DEFAULT_DETECTION_CLASS_STYLES, DEFAULT_DETECTION_COLOR_SEQUENCE, DepthColormap, DepthMapKind, DepthPreviewLevels, DepthQuantity, DepthSampling, 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, PLAYHEAD_QUANTIZATION_TOLERANCE_SECONDS, PercentageBarPlacement, PlaybackGateReach, RegionRendererComposeMode, RegionRendererCoverageKind, RegionRendererMediaEffectKind, RegionRendererRegionKind, RegionRendererSizeSpace, RegionRendererSourceKind, SUPERVISION_ROBOFLOW_COLOR, ShapeInstructionKind, StrokeAlignment, TrackingGeometry, annotationRendererKinds, annotationRenderers, applyAnnotationHandleDrag, canReuseMaskStyleArtifacts, centerRectToTopLeftRect, computeDepthPercentileRange, computeDetectionMaskRect, computeMaskBounds, containsPoint, convertDetectionBoxToMask, convertDetectionBoxToPolygon, convertDetectionMaskToBox, convertDetectionMaskToPolygon, convertDetectionPolygonToBox, convertDetectionPolygonToMask, copySortedDetectionFrames, createAnnotationEditingEngine, createArrayDetectionFrameSource, createBufferedDetectionTimeline, createByteTrackTracker, createCBIoUTracker, createColdDetectionFrameSource, createCompositeDetectionFrameSource, createDefaultAnnotationPresentation, createDepthColormapLut, createDetectionPickKey, createEditableAnnotationFrameSession, createIdMaskFrame, createIdleDetectionBufferState, createMemoryColdDetectionFrameStore, createOCSortTracker, createProjectedDetectionFrameSource, createSortTracker, createSourceAwarePresentation, createViewportController, createWritableDetectionFrameSource, decodeCompressedRleCounts, decodeCompressedRleMask, decodeDetectionMaskPayload, deleteAnnotationVertex, depthColormapColors, depthPreviewTopCode, detectMaskBorders, detectionFrameOverlapsRange, detectionPostProcessors, distanceToSegment, encodeBinaryMask, encodeBinaryMaskWithBounds, encodeCompressedRleCounts, encodeDetectionMaskPayload, extractDetectionMaskRectRuns, extractMaskContour, extractMaskRectRuns, filterDetectionFramesForRange, findClosestAnnotationSegment, followDetectionPickAcrossFrames, getAnnotationHandles, getBufferedDetectionTimelineFrameSnapshot, getDetectionRect, getPointsRect, haveSameDetectionPickIdentities, includeDefined, isDeflatedBase64DetectionMaskPayload, isDepthColormap, lightenColor, mediaToScreen, mergeDetectionMasks, mergeDetectionPolygonsByClass, normalizeDetectionClassName, offsetDetection, parseDepthManifest, pickAnnotationHandle, pickDetectionAtPoint, pickDetectionByMaskId, pointInPolygon, polygonArea, polygonToRect, projectDetectionFrame, projectDetectionFrameForTracking, projectDetectionFrames, rasterizePolygonToMask, rasterizeRectToMask, readDepthAt, rebaseDetectionPickToFrame, rectArea, rectToPolygon, resolveAnnotationRendererPresentation, resolveAnnotationRendererStyleFields, resolveAnnotationStyleState, resolveContrastTextColor, resolveDepthColorMapping, resolveDepthFrameFile, resolveDepthQuantity, resolveDetectionClassColorStyle, resolveEllipseSegmentCount, resolveIdMaskPaletteId, resolveIdMaskStrokeTexels, resolveMarkerGeometry, resolveMaskStyleOpacity, resolveStyleValue, sampleEllipseArc, screenToMedia, selectDetectionFrame, sortedDetectionFrames, topLeftRectToCenterRect, validateDepthMap, validateDetectionFrames, writeIdMaskPaletteEntry };
 //# sourceMappingURL=index.js.map