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

package/dist/index.cjs

@@ -3,7 +3,7 @@
 var jsSha256 = require('js-sha256');
 
 // src/version.ts
-var SDK_VERSION = "0.1.0";
+var SDK_VERSION = "0.3.0";
 var SDK_NAME = "posetracker-web";
 
 // src/api/configure.ts
@@ -24,7 +24,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 {
@@ -461,6 +462,135 @@ function stopMediaStream(stream) {
   }
 }
 
+// src/media/resolveMedia.ts
+function isVideoElement(v) {
+  return typeof HTMLVideoElement !== "undefined" && v instanceof HTMLVideoElement;
+}
+function isImageElement(v) {
+  return typeof HTMLImageElement !== "undefined" && v instanceof HTMLImageElement;
+}
+function isImageBitmap(v) {
+  return typeof ImageBitmap !== "undefined" && v instanceof ImageBitmap;
+}
+function mediaSize(el) {
+  if (isImageBitmap(el)) {
+    return { width: el.width || 0, height: el.height || 0 };
+  }
+  if (isVideoElement(el)) {
+    return { width: el.videoWidth || 0, height: el.videoHeight || 0 };
+  }
+  return {
+    width: el.naturalWidth || el.width || 0,
+    height: el.naturalHeight || el.height || 0
+  };
+}
+async function resolveObjectUrl(src) {
+  if (typeof src === "string") {
+    return { url: src, revoke: () => void 0 };
+  }
+  const url = URL.createObjectURL(src);
+  return {
+    url,
+    revoke: () => {
+      try {
+        URL.revokeObjectURL(url);
+      } catch {
+      }
+    }
+  };
+}
+function waitForVideoReady(video, timeoutMs = 15e3) {
+  return new Promise((resolve, reject) => {
+    if (video.readyState >= 2 && video.videoWidth > 0) {
+      resolve();
+      return;
+    }
+    const onReady = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("Failed to load video source"));
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error("Timed out waiting for video metadata"));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      video.removeEventListener("loadeddata", onReady);
+      video.removeEventListener("error", onError);
+    };
+    video.addEventListener("loadeddata", onReady);
+    video.addEventListener("error", onError);
+  });
+}
+function waitForImageReady(img, timeoutMs = 15e3) {
+  return new Promise((resolve, reject) => {
+    if (img.complete && img.naturalWidth > 0) {
+      resolve();
+      return;
+    }
+    if (img.complete) {
+      reject(new Error("Image failed to decode (naturalWidth=0)"));
+      return;
+    }
+    const onReady = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("Failed to load image source"));
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error("Timed out waiting for image"));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      img.removeEventListener("load", onReady);
+      img.removeEventListener("error", onError);
+    };
+    img.addEventListener("load", onReady);
+    img.addEventListener("error", onError);
+  });
+}
+async function imageBitmapToObjectUrl(bitmap) {
+  const canvas = document.createElement("canvas");
+  canvas.width = bitmap.width;
+  canvas.height = bitmap.height;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("2d context unavailable");
+  ctx.drawImage(bitmap, 0, 0);
+  const blob = await new Promise((resolve, reject) => {
+    canvas.toBlob((b) => b ? resolve(b) : reject(new Error("toBlob failed")), "image/png");
+  });
+  return resolveObjectUrl(blob);
+}
+
+// src/types/source.ts
+function normalizePoseSource(source, extras) {
+  if (source && typeof source === "object" && "type" in source) {
+    return source;
+  }
+  const kind = source === "video" || source === "image" || source === "camera" ? source : "camera";
+  if (kind === "camera") {
+    return { type: "camera", facingMode: extras?.facingMode };
+  }
+  const src = extras?.sourceFile ?? extras?.sourceUrl;
+  if (!src) {
+    throw new Error(
+      `PoseSource type "${kind}" requires sourceUrl or sourceFile (or pass a full PoseSource object)`
+    );
+  }
+  if (kind === "video") {
+    return { type: "video", src };
+  }
+  return { type: "image", src };
+}
+
 // src/exercises/aliases.ts
 var EXERCISE_ALIASES = {
   face_squat: "squat",
@@ -489,6 +619,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",
@@ -913,6 +1056,18 @@ async function resolvePoseDetection(options) {
 }
 
 // src/models/adapters/blazepose.ts
+function blazeInputSize(input) {
+  if (typeof HTMLVideoElement !== "undefined" && input instanceof HTMLVideoElement) {
+    return { vw: input.videoWidth || 0, vh: input.videoHeight || 0 };
+  }
+  if (typeof HTMLImageElement !== "undefined" && input instanceof HTMLImageElement) {
+    return { vw: input.naturalWidth || input.width || 0, vh: input.naturalHeight || input.height || 0 };
+  }
+  if (typeof HTMLCanvasElement !== "undefined" && input instanceof HTMLCanvasElement) {
+    return { vw: input.width || 0, vh: input.height || 0 };
+  }
+  return { vw: input.width || 0, vh: input.height || 0 };
+}
 var BLAZE_TO_COCO = {
   nose: "nose",
   left_eye: "left_eye",
@@ -932,6 +1087,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";
@@ -952,15 +1124,34 @@ var BlazePoseAdapter = class {
       {
         runtime: "tfjs",
         modelType: this.modelType,
-        enableSmoothing: true
+        enableSmoothing: false
       }
     );
   }
-  async estimate(video, options) {
+  async estimate(input, options) {
     if (!this.detector) throw new Error("BlazePose adapter not loaded");
-    if (!(video.videoWidth > 0 && video.videoHeight > 0)) return null;
+    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(video, {
+    const poses = await this.detector.estimatePoses(estimateTarget, {
       flipHorizontal: false,
       maxPoses: 1
     });
@@ -980,27 +1171,33 @@ var BlazePoseAdapter = class {
         letterbox: {
           offsetX: 0,
           offsetY: 0,
-          drawW: video.videoWidth,
-          drawH: video.videoHeight,
-          vw: video.videoWidth,
-          vh: video.videoHeight
+          drawW: size.vw,
+          drawH: size.vh,
+          vw: size.vw,
+          vh: size.vh
         }
       };
     }
-    const vw = video.videoWidth || 1;
-    const vh = video.videoHeight || 1;
+    const vw = size.vw || 1;
+    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);
@@ -1029,6 +1226,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,
@@ -1044,6 +1254,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?.();
@@ -1054,14 +1271,27 @@ var BlazePoseAdapter = class {
 };
 
 // src/models/adapters/movenet.ts
+function inputSize(input) {
+  if (typeof HTMLVideoElement !== "undefined" && input instanceof HTMLVideoElement) {
+    return { vw: input.videoWidth || 0, vh: input.videoHeight || 0 };
+  }
+  if (typeof HTMLImageElement !== "undefined" && input instanceof HTMLImageElement) {
+    return { vw: input.naturalWidth || input.width || 0, vh: input.naturalHeight || input.height || 0 };
+  }
+  if (typeof HTMLCanvasElement !== "undefined" && input instanceof HTMLCanvasElement) {
+    return { vw: input.width || 0, vh: input.height || 0 };
+  }
+  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) {
@@ -1078,6 +1308,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,
@@ -1117,19 +1359,81 @@ var MoveNetGraphAdapter = class {
     if (!this.offCtx) throw new Error("2d context unavailable");
     return this.offCtx;
   }
-  prepareInput(video) {
-    const vw = video.videoWidth || 1;
-    const vh = video.videoHeight || 1;
-    const scale = Math.min(INPUT_SIZE / vw, INPUT_SIZE / vh);
-    const drawW = vw * scale;
-    const drawH = vh * scale;
+  prepareInput(input, trackRoi) {
+    const { vw: rawW, vh: rawH } = inputSize(input);
+    const vw = rawW || 1;
+    const vh = rawH || 1;
+    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(video, 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) {
@@ -1145,20 +1449,26 @@ var MoveNetGraphAdapter = class {
     }
     return this.smoothed;
   }
-  async estimate(video, options) {
+  async estimate(input, options) {
     if (!this.tf || !this.model) throw new Error("MoveNet adapter not loaded");
-    if (!(video.videoWidth > 0 && video.videoHeight > 0)) return null;
+    const size = inputSize(input);
+    if (!(size.vw > 0 && size.vh > 0)) return null;
     const t0 = performance.now();
-    const canvas = this.prepareInput(video);
-    const input = this.tf.tidy(() => this.tf.expandDims(this.tf.browser.fromPixels(canvas), 0));
-    const out = this.model.execute(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)
+    );
+    const out = this.model.execute(tensorIn);
     const tensor = Array.isArray(out) ? out[0] : out;
     const data = tensor.dataSync();
-    input.dispose();
+    tensorIn.dispose();
     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 = [];
@@ -1176,7 +1486,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,
@@ -1184,7 +1495,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;
@@ -1201,9 +1512,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();
@@ -1211,6 +1528,8 @@ var MoveNetGraphAdapter = class {
     }
     this.model = null;
     this.smoothed = null;
+    this.lastVideoKps = null;
+    this.stillPass = 0;
     this.offscreen = null;
     this.offCtx = null;
   }
@@ -1283,11 +1602,11 @@ var SHELL_CSS = `
   position: relative; width: 100%; height: 100%; min-height: 240px;
   background: #000; overflow: hidden; isolation: isolate;
 }
-.pt-root video, .pt-root canvas.pt-overlay {
+.pt-root video, .pt-root img.pt-still, .pt-root canvas.pt-overlay {
   position: absolute; inset: 0; width: 100%; height: 100%;
   object-fit: cover; opacity: 0; transition: opacity 180ms ease-out;
 }
-.pt-root video { z-index: 1; background: #000; }
+.pt-root video, .pt-root img.pt-still { z-index: 1; background: #000; }
 .pt-root canvas.pt-overlay { z-index: 2; pointer-events: none; }
 .pt-boot {
   position: absolute; inset: 0; z-index: 4;
@@ -1361,6 +1680,7 @@ function mountDomShell(host, options = {}) {
   root.className = "pt-root";
   root.innerHTML = `
     <video playsinline muted autoplay></video>
+    <img class="pt-still" alt="" draggable="false" />
     <canvas class="pt-overlay"></canvas>
     <div class="pt-boot">
       <div class="pt-boot-powered">Powered by</div>
@@ -1377,6 +1697,7 @@ function mountDomShell(host, options = {}) {
   `;
   host.appendChild(root);
   const video = root.querySelector("video");
+  const image = root.querySelector("img.pt-still");
   const canvas = root.querySelector("canvas.pt-overlay");
   const boot = root.querySelector(".pt-boot");
   const bootMsg = root.querySelector(".pt-boot-msg");
@@ -1386,6 +1707,7 @@ function mountDomShell(host, options = {}) {
   return {
     root,
     video,
+    image,
     canvas,
     boot,
     bootMsg,
@@ -1397,10 +1719,21 @@ function mountDomShell(host, options = {}) {
       bootMsg.classList.toggle("is-error", isError);
     },
     setCameraVisible(visible) {
-      video.style.opacity = visible ? "1" : "0";
-      canvas.style.opacity = visible ? "1" : "0";
-      boot.classList.toggle("hide", visible);
-      if (!visible) {
+      if (visible) {
+        this.setMediaMode(image.src ? "image" : "video");
+      } else {
+        this.setMediaMode("none");
+      }
+    },
+    setMediaMode(mode) {
+      const showVideo = mode === "video";
+      const showImage = mode === "image";
+      const showMedia = showVideo || showImage;
+      video.style.opacity = showVideo ? "1" : "0";
+      image.style.opacity = showImage ? "1" : "0";
+      canvas.style.opacity = showMedia ? "1" : "0";
+      boot.classList.toggle("hide", showMedia);
+      if (!showMedia) {
         bootMsg.textContent = loadingText;
         bootMsg.classList.remove("is-error");
       }
@@ -1425,6 +1758,7 @@ function mountDomShell(host, options = {}) {
     applyMirror(facingMode) {
       const t = facingMode === "user" ? "scaleX(-1)" : "none";
       video.style.transform = t;
+      image.style.transform = "none";
       canvas.style.transform = t;
     },
     destroy() {
@@ -1628,6 +1962,10 @@ var PoseTrackerClient = class {
     this.keypointsSuppressionLogged = false;
     this.shell = null;
     this.stream = null;
+    this.poseSource = { type: "camera" };
+    this.objectUrlRevoke = null;
+    this.estimateInput = null;
+    this.imageShotPending = false;
     this.adapter = null;
     this.running = false;
     this.busy = false;
@@ -1654,6 +1992,15 @@ var PoseTrackerClient = class {
     this.resolved = resolvePoseModel({ model: options.model, modelUrl: options.modelUrl });
     this.skeletonDef = options.skeletonDef ?? null;
     this.coldStartMode = options.coldStart === "full" ? "full" : "basic";
+    try {
+      this.poseSource = normalizePoseSource(options.source, {
+        sourceUrl: options.sourceUrl,
+        sourceFile: options.sourceFile,
+        facingMode: facingFromOptions(options)
+      });
+    } catch {
+      this.poseSource = { type: "camera", facingMode: facingFromOptions(options) };
+    }
     this.files = options.fileStore !== void 0 ? options.fileStore : createWebFileStore();
     this.engineLoader = options.engineLoader ?? new EngineLoader({
       fileStore: this.files,
@@ -1700,6 +2047,10 @@ var PoseTrackerClient = class {
   getColdStartMode() {
     return this.coldStartMode;
   }
+  /** Active pose input source (`camera` | `video` | `image`). */
+  getSource() {
+    return this.poseSource;
+  }
   addEventListener(listener) {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -1763,31 +2114,102 @@ var PoseTrackerClient = class {
   warmup(options) {
     return this.preload(options);
   }
-  /** Mount + load model + open camera + start loop (camera-screen convenience). */
+  /**
+   * Mount + load model + open source + start inference.
+   * Camera / video stream continuously; image runs a single shot (re-run with {@link analyze}).
+   */
   async start() {
     if (this.disposed) throw new Error("PoseTracker disposed");
     if (!this.shell) throw new Error("Call mount() before start()");
-    await this.preload({ coldStart: this.opts.coldStart === "basic" ? "basic" : "full" });
-    if (this.coldStartMode === "basic") {
-      await this.ensureColdStartMode("full");
+    const needsMedia = this.poseSource.type === "camera" || this.poseSource.type === "video" || this.poseSource.type === "image";
+    await this.preload({
+      coldStart: this.opts.coldStart === "basic" && this.poseSource.type === "camera" ? "basic" : needsMedia ? "full" : "basic"
+    });
+    if (this.coldStartMode === "basic" || !this.estimateInput) {
+      await this.ensureSource();
+    }
+    if (this.poseSource.type === "image") {
+      this.imageShotPending = true;
     }
     this.beginLoop();
   }
+  /**
+   * Switch input source. Stops the current media, attaches the new source, and
+   * restarts the loop when previously running.
+   */
+  async setSource(source, extras) {
+    if (this.disposed) throw new Error("PoseTracker disposed");
+    const wasRunning = this.running;
+    this.stopMediaOnly();
+    this.poseSource = normalizePoseSource(source, {
+      sourceUrl: extras?.sourceUrl ?? this.opts.sourceUrl,
+      sourceFile: extras?.sourceFile ?? this.opts.sourceFile,
+      facingMode: extras?.facingMode ?? facingFromOptions(this.opts)
+    });
+    this.opts.source = this.poseSource;
+    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;
+      this.beginLoop();
+    }
+  }
+  /**
+   * Re-run pose estimation on the current still image (no-op for camera/video
+   * while the loop is already running — for those, call {@link start}).
+   */
+  async analyze() {
+    if (this.disposed) throw new Error("PoseTracker disposed");
+    if (!this.shell) throw new Error("Call mount() before analyze()");
+    await this.ensureAdapter();
+    if (!this.estimateInput) await this.ensureSource();
+    if (this.poseSource.type === "image") {
+      this.imageShotPending = true;
+      if (!this.running) this.beginLoop();
+      return null;
+    }
+    return this.runOneFrame();
+  }
   stop() {
     this.running = false;
     this.loopToken += 1;
     this.busy = false;
-    stopMediaStream(this.stream);
-    this.stream = null;
+    this.imageShotPending = false;
+    this.stopMediaOnly();
     if (this.shell) {
-      this.shell.video.srcObject = null;
-      this.shell.setCameraVisible(false);
+      this.shell.setMediaMode("none");
       this.shell.setPlacementVisible(false);
       this.cameraRevealed = false;
       this.applyWatermark();
     }
     if (this.status !== "error") this.setStatus("idle");
   }
+  stopMediaOnly() {
+    stopMediaStream(this.stream);
+    this.stream = null;
+    this.estimateInput = null;
+    if (this.objectUrlRevoke) {
+      this.objectUrlRevoke();
+      this.objectUrlRevoke = null;
+    }
+    if (this.shell) {
+      try {
+        this.shell.video.pause();
+      } catch {
+      }
+      this.shell.video.removeAttribute("src");
+      this.shell.video.srcObject = null;
+      this.shell.video.load();
+      this.shell.image.removeAttribute("src");
+    }
+  }
   async dispose() {
     this.stopExercise();
     this.stop();
@@ -1844,7 +2266,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 [];
@@ -1880,6 +2325,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) {
@@ -1893,8 +2360,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(
       {
@@ -2056,7 +2527,7 @@ var PoseTrackerClient = class {
   async ensureColdStartMode(mode) {
     if (mode !== "full") return;
     if (!this.shell) return;
-    await this.ensureCamera();
+    await this.ensureSource();
   }
   async ensureAdapter() {
     if (this.adapter) return;
@@ -2073,48 +2544,102 @@ var PoseTrackerClient = class {
     this.adapter = createPoseAdapter({ resolved: this.resolved });
     await this.adapter.load();
   }
-  async ensureCamera() {
-    if (!this.shell) throw new Error("Call mount() before opening the camera");
-    if (this.stream) return;
+  async ensureSource() {
+    if (!this.shell) throw new Error("Call mount() before opening a pose source");
+    const src = this.poseSource;
+    if (src.type === "camera") {
+      if (this.stream && this.estimateInput) return;
+      this.emit({
+        type: "initialization",
+        step: "accessing_webcam",
+        message: "accessing webcam (source=camera)",
+        ready: false
+      });
+      try {
+        this.stream = await openCameraStream({
+          facingMode: src.facingMode ?? facingFromOptions(this.opts),
+          idealWidth: this.opts.idealWidth,
+          idealHeight: this.opts.idealHeight
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const denied = /NotAllowed|Permission|denied/i.test(msg);
+        this.reportError({
+          type: "error",
+          code: denied ? "camera_denied" : "camera_unavailable",
+          message: msg
+        });
+        this.shell.setBootMessage(
+          denied ? "Camera permission denied \u2014 allow access in the browser" : "Camera unavailable",
+          true
+        );
+        throw err;
+      }
+      this.shell.video.srcObject = this.stream;
+      this.shell.applyMirror(src.facingMode ?? facingFromOptions(this.opts));
+      this.shell.setMediaMode("video");
+      try {
+        await this.shell.video.play();
+      } catch {
+      }
+      this.estimateInput = this.shell.video;
+      this.scheduleReveal("camera");
+      void this.handleCameraStart({
+        backend: this.acceleration.backend ?? "webgl",
+        profileId: null
+      });
+      return;
+    }
+    if (src.type === "video") {
+      this.emit({
+        type: "initialization",
+        step: "loading_media",
+        message: "loading video (source=video)",
+        ready: false
+      });
+      try {
+        await this.attachVideoSource(src.src, {
+          autoplay: src.autoplay !== false,
+          loop: src.loop !== false,
+          muted: src.muted !== false
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.reportError({ type: "error", code: "media_load_failed", message: msg });
+        this.shell.setBootMessage("Could not load video source", true);
+        throw err;
+      }
+      this.shell.applyMirror("none");
+      this.shell.setMediaMode("video");
+      this.scheduleReveal("video");
+      return;
+    }
     this.emit({
       type: "initialization",
-      step: "accessing_webcam",
-      message: "accessing webcam",
+      step: "loading_media",
+      message: "loading image (source=image)",
       ready: false
     });
     try {
-      this.stream = await openCameraStream({
-        facingMode: facingFromOptions(this.opts),
-        idealWidth: this.opts.idealWidth,
-        idealHeight: this.opts.idealHeight
-      });
+      await this.attachImageSource(src.src);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      const denied = /NotAllowed|Permission|denied/i.test(msg);
-      this.reportError({
-        type: "error",
-        code: denied ? "camera_denied" : "camera_unavailable",
-        message: msg
-      });
-      this.shell.setBootMessage(
-        denied ? "Camera permission denied \u2014 allow access in the browser" : "Camera unavailable",
-        true
-      );
+      this.reportError({ type: "error", code: "media_load_failed", message: msg });
+      this.shell.setBootMessage("Could not load image source", true);
       throw err;
     }
-    this.shell.video.srcObject = this.stream;
-    this.shell.applyMirror(facingFromOptions(this.opts));
-    try {
-      await this.shell.video.play();
-    } catch {
-    }
+    this.shell.applyMirror("none");
+    this.shell.setMediaMode("image");
+    this.scheduleReveal("image");
+  }
+  scheduleReveal(kind) {
     const started = Date.now();
     const tick = () => {
       this.revealCamera();
       if (this.cameraRevealed) return;
       if (Date.now() - started > 8e3) {
         this.shell?.setBootMessage(
-          "camera started but preview is empty \u2014 check permissions",
+          `${kind} loaded but preview is empty \u2014 check the file or CORS`,
           true
         );
         return;
@@ -2122,88 +2647,200 @@ var PoseTrackerClient = class {
       setTimeout(tick, 120);
     };
     setTimeout(tick, 60);
-    void this.handleCameraStart({
-      backend: this.acceleration.backend ?? "webgl",
-      profileId: null
-    });
+  }
+  async attachVideoSource(src, opts) {
+    if (!this.shell) throw new Error("no shell");
+    const video = this.shell.video;
+    if (isVideoElement(src)) {
+      if (src.parentElement && src !== video) {
+        this.estimateInput = src;
+        if (opts.autoplay) {
+          try {
+            await src.play();
+          } catch {
+          }
+        }
+        await waitForVideoReady(src);
+        return;
+      }
+      if (src.srcObject) {
+        video.srcObject = src.srcObject;
+      } else if (src.currentSrc || src.src) {
+        video.src = src.currentSrc || src.src;
+      }
+    } else {
+      const resolved = await resolveObjectUrl(src);
+      this.objectUrlRevoke = resolved.revoke;
+      video.src = resolved.url;
+    }
+    video.loop = opts.loop;
+    video.muted = opts.muted;
+    video.playsInline = true;
+    await waitForVideoReady(video);
+    if (opts.autoplay) {
+      try {
+        await video.play();
+      } catch {
+      }
+    }
+    this.estimateInput = video;
+  }
+  async attachImageSource(src) {
+    if (!this.shell) throw new Error("no shell");
+    if (isImageBitmap(src)) {
+      const resolved2 = await imageBitmapToObjectUrl(src);
+      this.objectUrlRevoke = resolved2.revoke;
+      this.shell.image.src = resolved2.url;
+      await waitForImageReady(this.shell.image);
+      this.estimateInput = src;
+      return;
+    }
+    if (isImageElement(src)) {
+      if (src.complete && src.naturalWidth > 0) {
+        this.shell.image.src = src.currentSrc || src.src;
+        this.estimateInput = src;
+        return;
+      }
+      await waitForImageReady(src);
+      this.shell.image.src = src.currentSrc || src.src;
+      this.estimateInput = src;
+      return;
+    }
+    const resolved = await resolveObjectUrl(src);
+    this.objectUrlRevoke = resolved.revoke;
+    this.shell.image.src = resolved.url;
+    await waitForImageReady(this.shell.image);
+    this.estimateInput = this.shell.image;
   }
   beginLoop() {
     this.running = true;
     this.fpsTimer = performance.now();
     void this.loop(++this.loopToken);
   }
+  frameReady(input) {
+    const size = mediaSize(
+      input
+    );
+    if (!(size.width > 0 && size.height > 0)) return false;
+    if (isVideoElement(input)) {
+      if (input.readyState < 2) return false;
+      if (this.poseSource.type === "video" && (input.paused || input.ended)) return false;
+    }
+    return true;
+  }
+  async runOneFrame() {
+    if (!this.adapter || !this.shell || !this.estimateInput) return null;
+    if (!this.frameReady(this.estimateInput)) return null;
+    const input = this.estimateInput;
+    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,
+      temporalSmooth: this.poseSource.type === "camera" || this.poseSource.type === "video" || stillTracked
+    });
+    if (!result) return null;
+    const ctx = this.shell.canvas.getContext("2d");
+    if (ctx && this.opts.drawSkeleton !== false) {
+      const mapped = mapVideoKeypointsToDisplay(
+        result.videoKeypoints,
+        result.letterbox,
+        clientW,
+        clientH
+      );
+      drawSkeleton(ctx, mapped, clientW, clientH, true, this.skeletonDef);
+    } else if (ctx && this.opts.drawSkeleton === false) {
+      ctx.clearRect(0, 0, clientW, clientH);
+    }
+    const pose = {
+      keypoints: result.keypoints,
+      score: result.score,
+      timestampMs: Date.now()
+    };
+    this.ingestPose(pose);
+    this.inferMs.push(result.inferenceMs);
+    if (this.inferMs.length > 30) this.inferMs.shift();
+    this.fpsWindow += 1;
+    const now = performance.now();
+    if (now - this.fpsTimer >= 1e3) {
+      const fps = this.fpsWindow;
+      this.fpsWindow = 0;
+      this.fpsTimer = now;
+      const med = median(this.inferMs);
+      this.acceleration.medianInferenceMs = med;
+      const above = result.keypoints.filter((k) => k.score >= 0.3).length;
+      const backend = "getBackend" in this.adapter && typeof this.adapter.getBackend === "function" ? this.adapter.getBackend() : null;
+      this.acceleration.backend = backend;
+      const size = mediaSize(input);
+      if (this.opts.debugHud) {
+        this.shell.setHud(
+          `${this.resolved.modelId} \xB7 ${this.poseSource.type} \xB7 ${backend ?? "?"} \xB7 ${fps} fps \xB7 ${med != null ? Math.round(med) + " ms" : "?"} \xB7 kp\u22650.3=${above}/17`,
+          true
+        );
+      }
+      this.emit({
+        type: "stats",
+        fps,
+        medianInferenceMs: med,
+        backend,
+        keypointsAbove03: above,
+        meanScore: result.score,
+        videoSize: `${size.width}x${size.height}`,
+        timestampMs: Date.now()
+      });
+    }
+    this.revealCamera();
+    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;
     }
-    const video = this.shell.video;
-    if (!this.busy && video.readyState >= 2 && video.videoWidth > 0) {
+    if (!this.adapter) {
+      requestAnimationFrame(() => {
+        void this.loop(token);
+      });
+      return;
+    }
+    const input = this.estimateInput;
+    const shouldInfer = !!input && !this.busy && this.frameReady(input) && (this.poseSource.type !== "image" || this.imageShotPending);
+    if (shouldInfer) {
       this.busy = true;
       try {
-        const dispW = this.shell.canvas.clientWidth || this.shell.root.clientWidth || 1;
-        const dispH = this.shell.canvas.clientHeight || this.shell.root.clientHeight || 1;
-        const result = await this.adapter.estimate(video, {
-          facingMode: facingFromOptions(this.opts),
-          displayWidth: dispW,
-          displayHeight: dispH
-        });
-        if (result) {
-          const ctx = this.shell.canvas.getContext("2d");
-          if (ctx && this.opts.drawSkeleton !== false) {
-            const mapped = mapVideoKeypointsToDisplay(
-              result.videoKeypoints,
-              result.letterbox,
-              dispW,
-              dispH
-            );
-            drawSkeleton(ctx, mapped, dispW, dispH, true, this.skeletonDef);
-          } else if (ctx && this.opts.drawSkeleton === false) {
-            ctx.clearRect(0, 0, dispW, dispH);
-          }
-          const pose = {
-            keypoints: result.keypoints,
-            score: result.score,
-            timestampMs: Date.now()
-          };
-          this.ingestPose(pose);
-          this.inferMs.push(result.inferenceMs);
-          if (this.inferMs.length > 30) this.inferMs.shift();
-          this.fpsWindow += 1;
-          const now = performance.now();
-          if (now - this.fpsTimer >= 1e3) {
-            const fps = this.fpsWindow;
-            this.fpsWindow = 0;
-            this.fpsTimer = now;
-            const med = median(this.inferMs);
-            this.acceleration.medianInferenceMs = med;
-            const above = result.keypoints.filter((k) => k.score >= 0.3).length;
-            const backend = "getBackend" in this.adapter && typeof this.adapter.getBackend === "function" ? this.adapter.getBackend() : null;
-            this.acceleration.backend = backend;
-            if (this.opts.debugHud) {
-              this.shell.setHud(
-                `${this.resolved.modelId} \xB7 ${backend ?? "?"} \xB7 ${fps} fps \xB7 ${med != null ? Math.round(med) + " ms" : "?"} \xB7 kp\u22650.3=${above}/17`,
-                true
-              );
-            }
-            this.emit({
-              type: "stats",
-              fps,
-              medianInferenceMs: med,
-              backend,
-              keypointsAbove03: above,
-              meanScore: result.score,
-              videoSize: `${video.videoWidth}x${video.videoHeight}`,
-              timestampMs: Date.now()
-            });
-          }
+        const pose = await this.runOneFrame();
+        if (this.poseSource.type === "image" && pose) {
+          this.imageShotPending = false;
+          this.running = false;
+          this.busy = false;
+          return;
         }
-        this.revealCamera();
       } 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;
     }
+    if (token !== this.loopToken || !this.running) return;
+    const videoEl = input && isVideoElement(input) ? input : this.shell.video;
+    if (this.poseSource.type !== "image" && typeof videoEl.requestVideoFrameCallback === "function" && (this.poseSource.type === "video" || this.poseSource.type === "camera")) {
+      videoEl.requestVideoFrameCallback(() => {
+        void this.loop(token);
+      });
+      return;
+    }
     requestAnimationFrame(() => {
       void this.loop(token);
     });
@@ -2460,14 +3097,19 @@ var PoseTrackerClient = class {
   }
   revealCamera() {
     if (!this.shell || this.cameraRevealed) return;
-    const v = this.shell.video;
-    if (!(v.videoWidth > 0 && v.videoHeight > 0)) return;
+    const input = this.estimateInput;
+    if (!input) return;
+    const size = mediaSize(input);
+    if (!(size.width > 0 && size.height > 0)) return;
     requestAnimationFrame(() => {
       requestAnimationFrame(() => {
         if (this.cameraRevealed || !this.shell) return;
-        if (!(this.shell.video.videoWidth > 0)) return;
         this.cameraRevealed = true;
-        this.shell.setCameraVisible(true);
+        if (this.poseSource.type === "image") {
+          this.shell.setMediaMode("image");
+        } else {
+          this.shell.setMediaMode("video");
+        }
         this.applyWatermark();
       });
     });
@@ -2576,6 +3218,7 @@ exports.SDK_VERSION = SDK_VERSION;
 exports.SkeletonFetchError = SkeletonFetchError;
 exports.TrackError = TrackError;
 exports.UsageTracker = UsageTracker;
+exports.V4_ONLY_EXERCISE_IDS = V4_ONLY_EXERCISE_IDS;
 exports.configure = configure;
 exports.createLocalFileStore = createLocalFileStore;
 exports.createLocalKeyValueStore = createLocalKeyValueStore;
@@ -2594,7 +3237,10 @@ exports.initWebGlBackend = initWebGlBackend;
 exports.isPaidPlan = isPaidPlan;
 exports.mapVideoKeypointsToDisplay = mapVideoKeypointsToDisplay;
 exports.mountDomShell = mountDomShell;
+exports.normalizeEngineChannel = normalizeEngineChannel;
+exports.normalizePoseSource = normalizePoseSource;
 exports.openCameraStream = openCameraStream;
+exports.requiresEngineV4 = requiresEngineV4;
 exports.resolveExerciseName = resolveExerciseName;
 exports.resolveFeatures = resolveFeatures;
 exports.resolvePoseDetection = resolvePoseDetection;