@pose-tracker/pose-estimation-web 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { sha256 } from 'js-sha256';
 
 // src/version.ts
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.3.0";
 var SDK_NAME = "posetracker-web";
 
 // src/api/configure.ts
@@ -22,7 +22,8 @@ async function configure(apiToken, options = {}) {
     targetPlatform: "web",
     poseModelProfile: options.poseModelProfile ?? "AdaptiveChoice",
     locale: options.locale,
-    localVersions: options.localVersions
+    localVersions: options.localVersions,
+    engineChannel: options.engine === "v4" ? "v4" : "v3"
   };
   let response;
   try {
@@ -529,6 +530,10 @@ function waitForImageReady(img, timeoutMs = 15e3) {
       resolve();
       return;
     }
+    if (img.complete) {
+      reject(new Error("Image failed to decode (naturalWidth=0)"));
+      return;
+    }
     const onReady = () => {
       cleanup();
       resolve();
@@ -612,6 +617,19 @@ function findExerciseByIdOrAlias(exerciseId, exercises) {
   return exercises.find((e) => resolveExerciseName(e.id) === canonical);
 }
 
+// src/engineChannel.ts
+var V4_ONLY_EXERCISE_IDS = [
+  "shoulder_roll",
+  "shoulder_deep_breath",
+  "chair_forward_fold"
+];
+function normalizeEngineChannel(raw) {
+  return raw === "v4" ? "v4" : "v3";
+}
+function requiresEngineV4(exerciseId) {
+  return V4_ONLY_EXERCISE_IDS.includes(exerciseId);
+}
+
 // src/events/classicMessage.ts
 var ANGLE_RELATIONS = {
   left_knee: "from_hip_to_ankle",
@@ -1067,6 +1085,23 @@ var BLAZE_TO_COCO = {
   left_ankle: "left_ankle",
   right_ankle: "right_ankle"
 };
+var FACE_EXTRA_NAMES = /* @__PURE__ */ new Set([
+  "left_eye_inner",
+  "left_eye_outer",
+  "right_eye_inner",
+  "right_eye_outer",
+  "mouth_left",
+  "mouth_right"
+]);
+var BLAZE_MAX_SIDE = 1280;
+function toSourcePixels(x, y, scratchW, scratchH, srcW, srcH, maxCoord) {
+  if (maxCoord <= 1.5 && scratchW > 2) {
+    return { x: x * srcW, y: y * srcH };
+  }
+  const sx = scratchW / srcW;
+  const sy = scratchH / srcH;
+  return { x: sx > 0 ? x / sx : x, y: sy > 0 ? y / sy : y };
+}
 var BlazePoseAdapter = class {
   constructor(_ctx) {
     this.modelId = "blazepose";
@@ -1087,7 +1122,7 @@ var BlazePoseAdapter = class {
       {
         runtime: "tfjs",
         modelType: this.modelType,
-        enableSmoothing: true
+        enableSmoothing: false
       }
     );
   }
@@ -1095,8 +1130,26 @@ var BlazePoseAdapter = class {
     if (!this.detector) throw new Error("BlazePose adapter not loaded");
     const size = blazeInputSize(input);
     if (!(size.vw > 0 && size.vh > 0)) return null;
+    if (options.temporalSmooth === false) this.resetTemporal();
+    let estimateTarget = input;
+    let scratch = null;
+    let scratchW = size.vw;
+    let scratchH = size.vh;
+    if (typeof HTMLImageElement !== "undefined" && input instanceof HTMLImageElement || typeof HTMLVideoElement !== "undefined" && input instanceof HTMLVideoElement || typeof HTMLCanvasElement !== "undefined" && input instanceof HTMLCanvasElement) {
+      const fit = Math.min(1, BLAZE_MAX_SIDE / Math.max(size.vw, size.vh));
+      scratchW = Math.max(1, Math.round(size.vw * fit));
+      scratchH = Math.max(1, Math.round(size.vh * fit));
+      scratch = document.createElement("canvas");
+      scratch.width = scratchW;
+      scratch.height = scratchH;
+      const ctx = scratch.getContext("2d");
+      if (ctx) {
+        ctx.drawImage(input, 0, 0, scratchW, scratchH);
+        estimateTarget = scratch;
+      }
+    }
     const t0 = performance.now();
-    const poses = await this.detector.estimatePoses(input, {
+    const poses = await this.detector.estimatePoses(estimateTarget, {
       flipHorizontal: false,
       maxPoses: 1
     });
@@ -1127,16 +1180,22 @@ var BlazePoseAdapter = class {
     const vh = size.vh || 1;
     const dispW = options.displayWidth || 1;
     const dispH = options.displayHeight || 1;
+    let maxCoord = 0;
+    for (const kp of pose.keypoints) {
+      maxCoord = Math.max(maxCoord, Math.abs(kp.x || 0), Math.abs(kp.y || 0));
+    }
     const byName = /* @__PURE__ */ new Map();
+    const extrasRaw = [];
     for (const kp of pose.keypoints) {
       const name = String(kp.name || "").toLowerCase();
+      const score = typeof kp.score === "number" ? kp.score : 0;
+      const src = toSourcePixels(kp.x, kp.y, scratchW, scratchH, vw, vh, maxCoord);
       const coco = BLAZE_TO_COCO[name];
-      if (!coco) continue;
-      byName.set(coco, {
-        x: kp.x,
-        y: kp.y,
-        score: typeof kp.score === "number" ? kp.score : 0
-      });
+      if (coco) {
+        byName.set(coco, { x: src.x, y: src.y, score });
+      } else if (FACE_EXTRA_NAMES.has(name)) {
+        extrasRaw.push({ name, x: src.x, y: src.y, score });
+      }
     }
     const videoKeypoints = COCO_KEYPOINT_NAMES.map((name) => {
       const k = byName.get(name);
@@ -1165,6 +1224,19 @@ var BlazePoseAdapter = class {
         score: k.score
       };
     });
+    for (const extra of extrasRaw) {
+      const dx = extra.x * scale + ox;
+      const dy = extra.y * scale + oy;
+      let nx = dispW > 0 ? dx / dispW : 0;
+      const ny = dispH > 0 ? dy / dispH : 0;
+      if (options.facingMode === "user") nx = 1 - nx;
+      keypoints.push({
+        name: extra.name,
+        x: Math.min(1, Math.max(0, nx)),
+        y: Math.min(1, Math.max(0, ny)),
+        score: extra.score
+      });
+    }
     return {
       keypoints,
       score: scoreSum / 17,
@@ -1180,6 +1252,13 @@ var BlazePoseAdapter = class {
       }
     };
   }
+  /** Clear cached ROI / landmark filters (call when the still changes). */
+  resetTemporal() {
+    try {
+      this.detector?.reset?.();
+    } catch {
+    }
+  }
   dispose() {
     try {
       this.detector?.dispose?.();
@@ -1203,13 +1282,14 @@ function inputSize(input) {
   return { vw: input.width || 0, vh: input.height || 0 };
 }
 var INPUT_SIZE = 192;
-var SMOOTH_ALPHA = 0.5;
+var SMOOTH_ALPHA = 0.45;
+var STILL_TARGET_FILL = 0.52;
 function modelNormToVideo(xNorm, yNorm, lb) {
   const xSq = xNorm * INPUT_SIZE;
   const ySq = yNorm * INPUT_SIZE;
   return {
-    x: (xSq - lb.offsetX) * (lb.vw / lb.drawW),
-    y: (ySq - lb.offsetY) * (lb.vh / lb.drawH)
+    x: (xSq - lb.offsetX) * (lb.vw / lb.drawW) + (lb.originX ?? 0),
+    y: (ySq - lb.offsetY) * (lb.vh / lb.drawH) + (lb.originY ?? 0)
   };
 }
 function videoToCover(vx, vy, dispW, dispH, lb) {
@@ -1226,6 +1306,18 @@ var MoveNetGraphAdapter = class {
     this.offscreen = null;
     this.offCtx = null;
     this.smoothed = null;
+    this.lastVideoKps = null;
+    this.stillPass = 0;
+    this.inferLb = {
+      offsetX: 0,
+      offsetY: 0,
+      drawW: INPUT_SIZE,
+      drawH: INPUT_SIZE,
+      vw: 1,
+      vh: 1,
+      originX: 0,
+      originY: 0
+    };
     this.letterbox = {
       offsetX: 0,
       offsetY: 0,
@@ -1265,20 +1357,81 @@ var MoveNetGraphAdapter = class {
     if (!this.offCtx) throw new Error("2d context unavailable");
     return this.offCtx;
   }
-  prepareInput(input) {
+  prepareInput(input, trackRoi) {
     const { vw: rawW, vh: rawH } = inputSize(input);
     const vw = rawW || 1;
     const vh = rawH || 1;
-    const scale = Math.min(INPUT_SIZE / vw, INPUT_SIZE / vh);
-    const drawW = vw * scale;
-    const drawH = vh * scale;
+    let winX = 0;
+    let winY = 0;
+    let winW = vw;
+    let winH = vh;
+    if (trackRoi && this.lastVideoKps && this.stillPass > 0) {
+      const pts = this.lastVideoKps.filter((k) => k.score >= 0.15);
+      if (pts.length >= 4) {
+        let minx = Infinity;
+        let miny = Infinity;
+        let maxx = -Infinity;
+        let maxy = -Infinity;
+        for (const p of pts) {
+          minx = Math.min(minx, p.xPx);
+          miny = Math.min(miny, p.yPx);
+          maxx = Math.max(maxx, p.xPx);
+          maxy = Math.max(maxy, p.yPx);
+        }
+        const bw = Math.max(8, maxx - minx);
+        const bh = Math.max(8, maxy - miny);
+        const cx = (minx + maxx) / 2;
+        const cy = (miny + maxy) / 2;
+        winW = Math.max(bw / STILL_TARGET_FILL, vw * 0.35);
+        winH = Math.max(bh / STILL_TARGET_FILL, vh * 0.35);
+        const imgAspect = vw / vh;
+        if (winW / winH < imgAspect) winW = winH * imgAspect;
+        else winH = winW / imgAspect;
+        winX = cx - winW / 2;
+        winY = cy - winH / 2;
+      }
+    }
+    const scale = Math.min(INPUT_SIZE / winW, INPUT_SIZE / winH);
+    const drawW = winW * scale;
+    const drawH = winH * scale;
     const offsetX = (INPUT_SIZE - drawW) / 2;
     const offsetY = (INPUT_SIZE - drawH) / 2;
-    this.letterbox = { offsetX, offsetY, drawW, drawH, vw, vh };
+    this.inferLb = {
+      offsetX,
+      offsetY,
+      drawW,
+      drawH,
+      vw: winW,
+      vh: winH,
+      originX: winX,
+      originY: winY
+    };
+    this.letterbox = { offsetX: 0, offsetY: 0, drawW: vw, drawH: vh, vw, vh };
     const c2d = this.poseCanvasCtx();
     c2d.fillStyle = "#000";
     c2d.fillRect(0, 0, INPUT_SIZE, INPUT_SIZE);
-    c2d.drawImage(input, 0, 0, vw, vh, offsetX, offsetY, drawW, drawH);
+    const srcX = Math.max(0, winX);
+    const srcY = Math.max(0, winY);
+    const srcR = Math.min(vw, winX + winW);
+    const srcB = Math.min(vh, winY + winH);
+    if (srcR > srcX && srcB > srcY) {
+      const dx = offsetX + (srcX - winX) * (drawW / winW);
+      const dy = offsetY + (srcY - winY) * (drawH / winH);
+      const dw = (srcR - srcX) * (drawW / winW);
+      const dh = (srcB - srcY) * (drawH / winH);
+      c2d.drawImage(
+        input,
+        srcX,
+        srcY,
+        srcR - srcX,
+        srcB - srcY,
+        dx,
+        dy,
+        dw,
+        dh
+      );
+    }
+    this.stillPass += 1;
     return this.offscreen;
   }
   smooth(raw) {
@@ -1299,7 +1452,9 @@ var MoveNetGraphAdapter = class {
     const size = inputSize(input);
     if (!(size.vw > 0 && size.vh > 0)) return null;
     const t0 = performance.now();
-    const canvas = this.prepareInput(input);
+    const isStill = typeof HTMLImageElement !== "undefined" && input instanceof HTMLImageElement;
+    const trackRoi = options.temporalSmooth !== false && isStill;
+    const canvas = this.prepareInput(input, trackRoi);
     const tensorIn = this.tf.tidy(
       () => this.tf.expandDims(this.tf.browser.fromPixels(canvas), 0)
     );
@@ -1310,7 +1465,8 @@ var MoveNetGraphAdapter = class {
     if (Array.isArray(out)) out.forEach((t) => t.dispose());
     else out.dispose();
     const inferenceMs = performance.now() - t0;
-    const lb = this.letterbox;
+    const lb = this.inferLb;
+    const coverLb = this.letterbox;
     const dispW = options.displayWidth || 1;
     const dispH = options.displayHeight || 1;
     const drawRaw = [];
@@ -1328,7 +1484,8 @@ var MoveNetGraphAdapter = class {
       });
       scoreSum += score;
     }
-    const sm = this.smooth(drawRaw);
+    const sm = options.temporalSmooth === false ? drawRaw : this.smooth(drawRaw);
+    this.lastVideoKps = sm.map((k) => ({ xPx: k.xPx, yPx: k.yPx, score: k.score }));
     const videoKeypoints = sm.map((k, i) => ({
       name: COCO_KEYPOINT_NAMES[i],
       xPx: k.xPx,
@@ -1336,7 +1493,7 @@ var MoveNetGraphAdapter = class {
       score: k.score
     }));
     const keypoints = videoKeypoints.map((k) => {
-      const d = videoToCover(k.xPx, k.yPx, dispW, dispH, lb);
+      const d = videoToCover(k.xPx, k.yPx, dispW, dispH, coverLb);
       let nx = dispW > 0 ? d.x / dispW : 0;
       const ny = dispH > 0 ? d.y / dispH : 0;
       if (options.facingMode === "user") nx = 1 - nx;
@@ -1353,9 +1510,15 @@ var MoveNetGraphAdapter = class {
       score: scoreSum / 17,
       inferenceMs,
       videoKeypoints,
-      letterbox: lb
+      letterbox: coverLb
     };
   }
+  /** Clear EMA state (call when the still / clip changes). */
+  resetTemporal() {
+    this.smoothed = null;
+    this.lastVideoKps = null;
+    this.stillPass = 0;
+  }
   dispose() {
     try {
       this.model?.dispose();
@@ -1363,6 +1526,8 @@ var MoveNetGraphAdapter = class {
     }
     this.model = null;
     this.smoothed = null;
+    this.lastVideoKps = null;
+    this.stillPass = 0;
     this.offscreen = null;
     this.offCtx = null;
   }
@@ -1983,7 +2148,11 @@ var PoseTrackerClient = class {
     if (this.poseSource.type === "camera" && this.poseSource.facingMode) {
       this.opts.facingMode = this.poseSource.facingMode;
     }
+    if (this.adapter?.resetTemporal) {
+      this.adapter.resetTemporal();
+    }
     if (!this.shell) return;
+    await this.ensureAdapter();
     await this.ensureSource();
     if (wasRunning || this.poseSource.type === "image") {
       if (this.poseSource.type === "image") this.imageShotPending = true;
@@ -2095,7 +2264,30 @@ var PoseTrackerClient = class {
     return this.configurePromise;
   }
   getAvailableExercises() {
-    return this.mode === "full-engine" ? this.manifest?.exercises ?? [] : [];
+    if (this.mode !== "full-engine") return [];
+    if (normalizeEngineChannel(this.opts.engine) === "v4") {
+      const listed = this.engine?.listExercises?.() ?? [];
+      if (listed.length) return listed.map((e) => this.v4ExerciseConfig(e));
+    }
+    return this.manifest?.exercises ?? [];
+  }
+  getEngineChannel() {
+    return normalizeEngineChannel(this.opts.engine);
+  }
+  v4ExerciseConfig(entry) {
+    const type = entry.type === "static" ? "static" : "dynamic";
+    return {
+      id: entry.id,
+      name: entry.displayName || entry.id,
+      type,
+      movement: {
+        name: entry.id,
+        type,
+        scale_acceptance: {},
+        movement_steps: [],
+        movement_initial_posture: null
+      }
+    };
   }
   getAvailableCustomExercises() {
     if (this.mode !== "full-engine" || !this.engine?.listCustomExercises) return [];
@@ -2131,6 +2323,28 @@ var PoseTrackerClient = class {
         throw new Error(FREE_PLAN_FEATURES_MESSAGE);
       }
     }
+    if (requiresEngineV4(exerciseId) && normalizeEngineChannel(this.opts.engine) !== "v4") {
+      const message = `Exercise '${exerciseId}' requires engine: 'v4'`;
+      this.reportError({ type: "error", code: "invalid_exercise", message });
+      throw new Error(message);
+    }
+    if (normalizeEngineChannel(this.opts.engine) === "v4") {
+      const listed = this.engine.listExercises?.() ?? [];
+      const v4Hit = listed.find((e) => e.id === exerciseId);
+      if (v4Hit) {
+        this.beginEngineSession(this.v4ExerciseConfig(v4Hit), options);
+        return;
+      }
+      const customs = this.getAvailableCustomExercises();
+      const custom = customs.find((e) => e.id === exerciseId) ?? findExerciseByIdOrAlias(exerciseId, customs);
+      if (custom) {
+        this.startCustomExercise(custom, options);
+        return;
+      }
+      const message = `Exercise '${exerciseId}' is not available in V4 engine`;
+      this.reportError({ type: "error", code: "invalid_exercise", message });
+      throw new Error(message);
+    }
     const available = this.getAvailableExercises();
     const exercise = findExerciseByIdOrAlias(exerciseId, available);
     if (!exercise) {
@@ -2144,8 +2358,12 @@ var PoseTrackerClient = class {
       this.reportError({ type: "error", code: "invalid_exercise", message });
       throw new Error(message);
     }
+    this.beginEngineSession(exercise, options);
+  }
+  beginEngineSession(exercise, options) {
+    if (!this.engine) return;
     this.stopExercise();
-    this.currentExerciseId = exerciseId;
+    this.currentExerciseId = exercise.id;
     this.keypointsSuppressionLogged = false;
     this.session = this.engine.createSession(
       {
@@ -2512,13 +2730,19 @@ var PoseTrackerClient = class {
     if (!this.adapter || !this.shell || !this.estimateInput) return null;
     if (!this.frameReady(this.estimateInput)) return null;
     const input = this.estimateInput;
-    const dispW = this.shell.canvas.clientWidth || this.shell.root.clientWidth || 1;
-    const dispH = this.shell.canvas.clientHeight || this.shell.root.clientHeight || 1;
+    const clientW = this.shell.canvas.clientWidth || this.shell.root.clientWidth || 1;
+    const clientH = this.shell.canvas.clientHeight || this.shell.root.clientHeight || 1;
+    const media = mediaSize(input);
+    const useMediaSpace = this.poseSource.type === "image" && media.width > 0 && media.height > 0;
+    const dispW = useMediaSpace ? media.width : clientW;
+    const dispH = useMediaSpace ? media.height : clientH;
     const facing = this.poseSource.type === "camera" ? facingFromOptions(this.opts) : "environment";
+    const stillTracked = this.poseSource.type === "image" && this.opts.stillMode === "tracked";
     const result = await this.adapter.estimate(input, {
       facingMode: facing,
       displayWidth: dispW,
-      displayHeight: dispH
+      displayHeight: dispH,
+      temporalSmooth: this.poseSource.type === "camera" || this.poseSource.type === "video" || stillTracked
     });
     if (!result) return null;
     const ctx = this.shell.canvas.getContext("2d");
@@ -2526,12 +2750,12 @@ var PoseTrackerClient = class {
       const mapped = mapVideoKeypointsToDisplay(
         result.videoKeypoints,
         result.letterbox,
-        dispW,
-        dispH
+        clientW,
+        clientH
       );
-      drawSkeleton(ctx, mapped, dispW, dispH, true, this.skeletonDef);
+      drawSkeleton(ctx, mapped, clientW, clientH, true, this.skeletonDef);
     } else if (ctx && this.opts.drawSkeleton === false) {
-      ctx.clearRect(0, 0, dispW, dispH);
+      ctx.clearRect(0, 0, clientW, clientH);
     }
     const pose = {
       keypoints: result.keypoints,
@@ -2574,7 +2798,13 @@ var PoseTrackerClient = class {
     return pose;
   }
   async loop(token) {
-    if (token !== this.loopToken || !this.running || !this.adapter || !this.shell || this.disposed) {
+    if (token !== this.loopToken || !this.running || !this.shell || this.disposed) {
+      return;
+    }
+    if (!this.adapter) {
+      requestAnimationFrame(() => {
+        void this.loop(token);
+      });
       return;
     }
     const input = this.estimateInput;
@@ -2582,8 +2812,8 @@ var PoseTrackerClient = class {
     if (shouldInfer) {
       this.busy = true;
       try {
-        await this.runOneFrame();
-        if (this.poseSource.type === "image") {
+        const pose = await this.runOneFrame();
+        if (this.poseSource.type === "image" && pose) {
           this.imageShotPending = false;
           this.running = false;
           this.busy = false;
@@ -2592,6 +2822,12 @@ var PoseTrackerClient = class {
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         this.emit({ type: "error", code: "internal", message: `inference: ${message}` });
+        if (this.poseSource.type === "image") {
+          this.imageShotPending = false;
+          this.running = false;
+          this.busy = false;
+          return;
+        }
       }
       this.busy = false;
     }
@@ -2953,6 +3189,6 @@ var PoseCamera = {
   mount: PoseCamera_mount
 };
 
-export { BRAND_COLORS, BlazePoseAdapter, COCO_KEYPOINT_NAMES, COMBINED_REFERENCE_EXERCISE_MESSAGE, ConfigureError, DEFAULT_BASE_URL, DEFAULT_FEATURES, DEFAULT_LOADING_TEXT, DEFAULT_MOVENET_LIGHTNING_URL, DEFAULT_SKELETON, DEFAULT_SKELETON_DEFINITION, EXERCISE_ALIASES, EngineLoader, FREE_PLAN_FEATURES_MESSAGE, INVALID_TOKEN_MESSAGE, MoveNetGraphAdapter, ONLINE_POSE_DETECTION_VERSION, ONLINE_TFJS_VERSION, POSETRACKER_LOGO_URL, PoseCamera, PoseCamera_mount, PoseTrackerClient, SDK_NAME, SDK_VERSION, SkeletonFetchError, TrackError, UsageTracker, configure, createLocalFileStore, createLocalKeyValueStore, createMemoryFileStore, createPoseAdapter, createPoseTracker, createWebFileStore, defaultPoseDetectionCdnUrl, defaultTfjsCdnUrls, drawSkeleton, featureNotSupportedMessage, fetchSkeletonDefinition, findExerciseByIdOrAlias, freeBlockedFeatures, initWebGlBackend, isPaidPlan, mapVideoKeypointsToDisplay, mountDomShell, normalizePoseSource, openCameraStream, resolveExerciseName, resolveFeatures, resolvePoseDetection, resolvePoseModel, resolveTf, shouldShowWatermark, stopMediaStream, toClassicNativeMessage };
+export { BRAND_COLORS, BlazePoseAdapter, COCO_KEYPOINT_NAMES, COMBINED_REFERENCE_EXERCISE_MESSAGE, ConfigureError, DEFAULT_BASE_URL, DEFAULT_FEATURES, DEFAULT_LOADING_TEXT, DEFAULT_MOVENET_LIGHTNING_URL, DEFAULT_SKELETON, DEFAULT_SKELETON_DEFINITION, EXERCISE_ALIASES, EngineLoader, FREE_PLAN_FEATURES_MESSAGE, INVALID_TOKEN_MESSAGE, MoveNetGraphAdapter, ONLINE_POSE_DETECTION_VERSION, ONLINE_TFJS_VERSION, POSETRACKER_LOGO_URL, PoseCamera, PoseCamera_mount, PoseTrackerClient, SDK_NAME, SDK_VERSION, SkeletonFetchError, TrackError, UsageTracker, V4_ONLY_EXERCISE_IDS, configure, createLocalFileStore, createLocalKeyValueStore, createMemoryFileStore, createPoseAdapter, createPoseTracker, createWebFileStore, defaultPoseDetectionCdnUrl, defaultTfjsCdnUrls, drawSkeleton, featureNotSupportedMessage, fetchSkeletonDefinition, findExerciseByIdOrAlias, freeBlockedFeatures, initWebGlBackend, isPaidPlan, mapVideoKeypointsToDisplay, mountDomShell, normalizeEngineChannel, normalizePoseSource, openCameraStream, requiresEngineV4, resolveExerciseName, resolveFeatures, resolvePoseDetection, resolvePoseModel, resolveTf, shouldShowWatermark, stopMediaStream, toClassicNativeMessage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map