react-native-nitro-pose-exercises 1.1.6 → 1.1.7

package/README.md

@@ -12,6 +12,7 @@ A **React Native Nitro Module** for real-time, on-device exercise tracking using
 * 🔄 **Rep Counting** — Automatic rep detection with configurable state machines
 * 🧘 **Hold Tracking** — Duration and stability tracking for planks, yoga poses, and isometric holds
 * 📐 **Form Validation** — Real-time form feedback with angle-based rules
+* 🚦 **Posture Gating** — Refuses to count reps unless the user is in valid posture; "Get in position" feedback before sessions start
 * 💀 **Skeleton Overlay** — Skia-powered skeleton with glow effects and live angle badges
 * ⚡ **Fully Native** — OS-level pose detection via Nitro Modules, zero JS bridge overhead
 * 📦 **Zero Model Bundling** — No ML model files to download or ship with your app
@@ -79,6 +80,7 @@ cd ios && pod install
 | --- | --- |
 | **Rep-Based Exercises** | Cyclic state machine (UP → DOWN → UP = 1 rep). Push-ups, squats, curls, and more. |
 | **Hold-Based Exercises** | Single target pose with duration + stability tracking. Planks, wall sits, yoga poses. |
+| **Posture Gate** | Family-based posture validation. Refuses to start or count reps until user is in correct position (e.g. horizontal for pushups, upright for squats). |
 | **Form Feedback** | Angle-based rules with throttled real-time callbacks. Bad form blocks rep counting. |
 | **Skeleton Overlay** | Glow-effect bones, color-coded joints, and live angle badges drawn over camera via Skia. |
 | **Bilateral Tracking** | Left and right side angles tracked independently. |
@@ -236,132 +238,6 @@ const styles = StyleSheet.create({
 });
 ```
 
-### Skeleton Overlay with Angle Badges — SkiaCamera
-
-> **Critical:** Create all `Skia.Paint()` and `Skia.Font()` objects **outside** the `onFrame` callback. Creating them inside causes memory leaks and crashes within seconds.
-
-```tsx
-import { Skia } from '@shopify/react-native-skia';
-import { SkiaCamera } from 'react-native-vision-camera-skia';
-import { nitroPoseExercises } from 'react-native-nitro-pose-exercises';
-
-// Create paints ONCE at module level — NEVER inside onFrame
-const GLOW_PAINT = Skia.Paint();
-GLOW_PAINT.setColor(Skia.Color('rgba(0, 255, 102, 0.3)'));
-GLOW_PAINT.setStrokeWidth(14);
-GLOW_PAINT.setStyle(1);
-GLOW_PAINT.setStrokeCap(1);
-GLOW_PAINT.setAntiAlias(true);
-
-const BONE_PAINT = Skia.Paint();
-BONE_PAINT.setColor(Skia.Color('#00FF66'));
-BONE_PAINT.setStrokeWidth(6);
-BONE_PAINT.setStyle(1);
-BONE_PAINT.setStrokeCap(1);
-BONE_PAINT.setAntiAlias(true);
-
-const JOINT_PAINT = Skia.Paint();
-JOINT_PAINT.setColor(Skia.Color('#FF3366'));
-JOINT_PAINT.setStyle(0);
-JOINT_PAINT.setAntiAlias(true);
-
-const KEY_JOINT_PAINT = Skia.Paint();
-KEY_JOINT_PAINT.setColor(Skia.Color('#00FFFF'));
-KEY_JOINT_PAINT.setStyle(0);
-KEY_JOINT_PAINT.setAntiAlias(true);
-
-const ANGLE_BG_PAINT = Skia.Paint();
-ANGLE_BG_PAINT.setColor(Skia.Color('rgba(0, 0, 0, 0.7)'));
-ANGLE_BG_PAINT.setStyle(0);
-
-const ANGLE_TEXT_FONT = Skia.Font(null, 14);
-const ANGLE_TEXT_PAINT = Skia.Paint();
-ANGLE_TEXT_PAINT.setColor(Skia.Color('#FFFFFF'));
-
-const SKELETON_CONNECTIONS = [
-  [11, 12], [11, 23], [12, 24], [23, 24],
-  [11, 13], [13, 15], [12, 14], [14, 16],
-  [23, 25], [25, 27], [24, 26], [26, 28],
-];
-
-const KEY_LANDMARKS = [11, 12, 13, 14, 15, 16, 23, 24, 25, 26, 27, 28];
-
-<SkiaCamera
-  style={StyleSheet.absoluteFill}
-  isActive={true}
-  device="back"
-  pixelFormat="rgb"
-  onFrame={(frame, render) => {
-    'worklet';
-    try {
-      nitroPoseExercises.processFrame(frame);
-      const landmarks = nitroPoseExercises.landmarks;
-
-      render(({ frameTexture, canvas }) => {
-        canvas.drawImage(frameTexture, 0, 0);
-
-        if (landmarks && landmarks.length > 0) {
-          const w = frame.width;
-          const h = frame.height;
-
-          // Glow layer (thick translucent)
-          for (const [i, j] of SKELETON_CONNECTIONS) {
-            if (i < landmarks.length && j < landmarks.length) {
-              const a = landmarks[i];
-              const b = landmarks[j];
-              if (a.visibility > 0.5 && b.visibility > 0.5) {
-                canvas.drawLine(a.x * w, a.y * h, b.x * w, b.y * h, GLOW_PAINT);
-              }
-            }
-          }
-
-          // Solid bones on top
-          for (const [i, j] of SKELETON_CONNECTIONS) {
-            if (i < landmarks.length && j < landmarks.length) {
-              const a = landmarks[i];
-              const b = landmarks[j];
-              if (a.visibility > 0.5 && b.visibility > 0.5) {
-                canvas.drawLine(a.x * w, a.y * h, b.x * w, b.y * h, BONE_PAINT);
-              }
-            }
-          }
-
-          // Joints with glow rings
-          for (let idx = 0; idx < landmarks.length; idx++) {
-            const lm = landmarks[idx];
-            if (lm && lm.visibility > 0.5) {
-              const isKey = KEY_LANDMARKS.includes(idx);
-              if (isKey) canvas.drawCircle(lm.x * w, lm.y * h, 12, GLOW_PAINT);
-              canvas.drawCircle(lm.x * w, lm.y * h, isKey ? 8 : 4, isKey ? KEY_JOINT_PAINT : JOINT_PAINT);
-            }
-          }
-
-          // Elbow angle badges
-          for (const [shoulderIdx, elbowIdx, wristIdx] of [[11, 13, 15], [12, 14, 16]]) {
-            const s = landmarks[shoulderIdx];
-            const e = landmarks[elbowIdx];
-            const wr = landmarks[wristIdx];
-            if (s?.visibility > 0.5 && e?.visibility > 0.5 && wr?.visibility > 0.5) {
-              const vaX = s.x - e.x, vaY = s.y - e.y;
-              const vcX = wr.x - e.x, vcY = wr.y - e.y;
-              const dot = vaX * vcX + vaY * vcY;
-              const mag = Math.sqrt(vaX * vaX + vaY * vaY) * Math.sqrt(vcX * vcX + vcY * vcY);
-              const angle = Math.round(Math.acos(Math.max(-1, Math.min(1, dot / mag))) * (180 / Math.PI));
-              const tx = e.x * w + 15;
-              const ty = e.y * h - 10;
-              canvas.drawRoundRect({ x: tx - 4, y: ty - 14, width: 48, height: 20 }, 6, 6, ANGLE_BG_PAINT);
-              canvas.drawText(`${angle}°`, tx, ty, ANGLE_TEXT_PAINT, ANGLE_TEXT_FONT);
-            }
-          }
-        }
-      });
-    } finally {
-      frame.dispose();
-    }
-  }}
-/>
-```
-
 ---
 
 ## 🧩 API Reference
@@ -389,6 +265,9 @@ startSession(targetReps: number, countdownSeconds: number): void
 pauseSession(): void
 resumeSession(): void
 stopSession(): void
+// Returns true if the user is currently in valid posture for the loaded exercise.
+// Poll this before starting a session, e.g. show "Get in position" until ready.
+isReady(): boolean
 ```
 
 ### Frame Processing
@@ -416,6 +295,8 @@ onFormFeedback: ((feedback: FormFeedback) => void) | undefined
 onHoldProgress: ((progress: HoldProgress) => void) | undefined
 onPoseLost: (() => void) | undefined
 onPoseRegained: (() => void) | undefined
+onPostureLost: (() => void) | undefined        
+onPostureRegained: (() => void) | undefined
 onSessionComplete: ((result: SessionResult) => void) | undefined
 ```
 
@@ -454,6 +335,74 @@ onSessionComplete: ((result: SessionResult) => void) | undefined
   angleHistory: AngleSnapshot[]
 }
 ```
+---
+
+## 🚦 Posture Gating
+
+Each exercise config declares a **posture family** that defines what body position is required before reps are counted. This prevents false counts — e.g. waving your arm while standing won't count as a push-up.
+
+### Posture Families
+
+| Family | Description | Used For |
+| --- | --- | --- |
+| `horizontalProne` | Body horizontal, face down. Shoulders, hips, ankles in a horizontal band. | Push-ups, planks, cobra, mountain climbers |
+| `standingUpright` | Standing, shoulders above hips above knees. | Squats, lunges, curls, presses, most yoga poses |
+| `seated` | Hips near knees, shoulders above hips. | Boat pose, seated yoga, child's pose |
+| `supine` | Body horizontal, face up. | Sit-ups, glute bridge, leg raises |
+| `sidePlank` | Body horizontal, rotated to one side. | Side plank, side leg raises |
+| `inverted` | Hips higher than shoulders and ankles. | Downward dog, handstand |
+| `none` | No posture gating. | Custom or unconstrained exercises |
+
+### Flow
+
+loadExercise(config)  →  poll isReady()  →  user gets in position  →
+isReady() returns true  →  startSession()  →  reps counted normally
+↓
+if posture breaks mid-session
+→ onPostureLost fires
+→ phase detection pauses
+→ in-progress rep discarded
+↓
+user re-enters position
+→ onPostureRegained fires
+→ counting resumes
+
+### Example: Wait for Position Before Starting
+
+```tsx
+const [isInPosition, setIsInPosition] = useState(false);
+
+useEffect(() => {
+// Wait for the user to get into position before starting
+const checkInterval = setInterval(() => {
+  if (nitroPoseExercises.isReady()) {
+    clearInterval(checkInterval);
+    nitroPoseExercises.startSession(10, 3);
+  }
+}, 300);
+  return () => clearInterval(interval);
+}, []);
+
+useEffect(() => {
+  nitroPoseExercises.onPostureLost = () => {
+    setMessage('Get back into position');
+  };
+  nitroPoseExercises.onPostureRegained = () => {
+    setMessage('');
+  };
+}, []);
+
+return (
+  <>
+    {!isInPosition && <Text>Get into push-up position</Text>}
+    {isInPosition && <Text>Hold still — starting...</Text>}
+  </>
+);
+```
+
+### Tuning
+
+Posture gates use a **10-frame hysteresis** (about 1 second at 30fps with frame throttling) — single-frame failures don't pause the session. This prevents flicker from momentary occlusion or visibility drops.
 
 ---
 
@@ -528,6 +477,7 @@ import type { ExerciseConfig } from 'react-native-nitro-pose-exercises';
 const MY_EXERCISE: ExerciseConfig = {
   name: 'Custom Exercise',
   type: 'rep',  // 'rep' | 'hold'
+  postureFamily: 'standingUpright',  // ← required: see table above
   angles: [
     { name: 'myAngle', landmarkA: 11, landmarkB: 13, landmarkC: 15 },
   ],
@@ -597,6 +547,8 @@ Each exercise config includes a `cameraAngle` recommendation (`'side'` or `'fron
 | **Pose lost detection** | `onPoseLost` / `onPoseRegained` callbacks when user exits/enters frame |
 | **Frame throttle** | Processes every 3rd frame to reduce CPU load without losing accuracy |
 | **Visibility filter** | Landmarks with confidence below 0.3 are excluded from angle calculations |
+| **Posture entry gate** | Sessions don't start counting until `isReady()` returns true |
+| **Posture hysteresis** | 10 consecutive failed frames required to fire `onPostureLost` — prevents flicker |
 
 ---
 

package/android/src/main/java/com/margelo/nitro/nitroposeexercises/NitroPoseExercises.kt

@@ -26,6 +26,7 @@ class NitroPoseExercises : HybridNitroPoseExercisesSpec() {
   private var poseDetector: PoseDetector? = null
   private var isInitialized = false
 
+
   // ─── Cached Landmarks (ML Kit is async, we cache last result) ──
   private var cachedLandmarks: Array<Landmark> = emptyArray()
   private val landmarkLock = Any()
@@ -115,6 +116,14 @@ class NitroPoseExercises : HybridNitroPoseExercisesSpec() {
   override var onPoseRegained: (() -> Unit)? = null
   override var onSessionComplete: ((result: SessionResult) -> Unit)? = null
 
+  override var onPostureLost: (() -> Unit)? = null
+override var onPostureRegained: (() -> Unit)? = null
+
+  // ─── Posture Gate ──────────────────────────────────────────
+private var consecutivePostureFailures: Int = 0
+private val postureFailureThreshold: Int = 10
+private var postureWasLost = false
+
   // ─── Hold Tracking ──────────────────────────────────────────
   private var holdStartTime: Long? = null
 
@@ -143,6 +152,12 @@ class NitroPoseExercises : HybridNitroPoseExercisesSpec() {
     resetSession()
   }
 
+  override fun isReady(): Boolean {
+  val config = exerciseConfig ?: return false
+  if (_landmarks.isEmpty()) return false
+  return isPostureValid(config.postureFamily)
+}
+
   // ═══════════════════════════════════════════════════════════
   // Exercise Setup
   // ═══════════════════════════════════════════════════════════
@@ -201,7 +216,10 @@ override fun processFrame(frame: HybridFrameSpec) {
       val nativeBuffer = frame.getNativeBuffer()
       val bitmap = FrameHelper.hardwareBufferToBitmap(nativeBuffer.pointer) ?: return
 
-      val inputImage = InputImage.fromBitmap(bitmap, 0)
+
+  val rotation = rotationDegreesFromFrame(frame)
+  val inputImage = InputImage.fromBitmap(bitmap, rotation)
+
       val imageWidth = bitmap.width.toDouble()
       val imageHeight = bitmap.height.toDouble()
 
@@ -270,9 +288,29 @@ override fun processFrame(frame: HybridFrameSpec) {
   // Exercise Logic Engine
   // ═══════════════════════════════════════════════════════════
 
-  private fun processExerciseLogic() {
-    val config = exerciseConfig ?: return
-    if (_landmarks.isEmpty()) return
+private fun processExerciseLogic() {
+  val config = exerciseConfig ?: return
+  if (_landmarks.isEmpty()) return
+
+  // Posture gate with hysteresis
+  if (!isPostureValid(config.postureFamily)) {
+    consecutivePostureFailures++
+    if (consecutivePostureFailures >= postureFailureThreshold) {
+      if (!postureWasLost) {
+        postureWasLost = true
+        onPostureLost?.invoke()
+      }
+      _currentPhase = ExercisePhase.UNKNOWN
+      phaseHistory.clear()
+    }
+    return
+  }
+
+  consecutivePostureFailures = 0
+  if (postureWasLost) {
+    postureWasLost = false
+    onPostureRegained?.invoke()
+  }
 
     val currentAngles = mutableMapOf<String, Double>()
     val angleSnapshots = mutableListOf<AngleSnapshot>()
@@ -511,6 +549,83 @@ override fun processFrame(frame: HybridFrameSpec) {
     onSessionComplete?.invoke(result)
   }
 
+  // ═══════════════════════════════════════════════════════════
+// Orientation Helpers
+// ═══════════════════════════════════════════════════════════
+
+private fun rotationDegreesFromFrame(frame: HybridFrameSpec): Int {
+  return when (frame.orientation.name.lowercase()) {
+    "up" -> 0
+    "right" -> 90
+    "down" -> 180
+    "left" -> 270
+    else -> 0
+  }
+}
+
+// ═══════════════════════════════════════════════════════════
+// Posture Gates
+// ═══════════════════════════════════════════════════════════
+
+private func isPostureValid(_ family: String) -> Bool {
+  guard _landmarks.count >= 33 else { return false }
+  
+  let visThreshold = exerciseConfig?.visibilityThreshold ?? 0.3
+  
+  if (_landmarks.size < 33) return false
+
+  val ls = _landmarks[11]; val rs = _landmarks[12]
+  val lh = _landmarks[23]; val rh = _landmarks[24]
+  val lk = _landmarks[25]; val rk = _landmarks[26]
+  val la = _landmarks[27]; val ra = _landmarks[28]
+
+  val keyVisible = ls.visibility > 0.3 && rs.visibility > 0.3 &&
+                   lh.visibility > 0.3 && rh.visibility > 0.3
+  if (!keyVisible) return false
+
+  val shoulderY = (ls.y + rs.y) / 2
+  val hipY = (lh.y + rh.y) / 2
+  val shoulderX = (ls.x + rs.x) / 2
+  val hipX = (lh.x + rh.x) / 2
+
+  val kneesVisible = lk.visibility > 0.3 && rk.visibility > 0.3
+  val anklesVisible = la.visibility > 0.3 && ra.visibility > 0.3
+  val kneeY = if (kneesVisible) (lk.y + rk.y) / 2 else hipY
+  val ankleY = if (anklesVisible) (la.y + ra.y) / 2 else kneeY
+
+  return when (family) {
+    "horizontalProne" -> {
+      val ys = listOf(shoulderY, hipY, ankleY)
+      (ys.max() - ys.min()) < 0.25
+    }
+    "standingUpright" -> {
+      if (!kneesVisible) false
+      else shoulderY < hipY - 0.08 &&
+           hipY < kneeY + 0.05 &&
+           (if (anklesVisible) kneeY < ankleY else true)
+    }
+    "seated" -> {
+      if (!kneesVisible) false
+      else shoulderY < hipY - 0.05 && kotlin.math.abs(hipY - kneeY) < 0.20
+    }
+    "supine" -> {
+      val ys = listOf(shoulderY, hipY, ankleY)
+      (ys.max() - ys.min()) < 0.25
+    }
+    "sidePlank" -> {
+      val ySpread = kotlin.math.abs(shoulderY - hipY)
+      val shoulderHipDx = kotlin.math.abs(shoulderX - hipX)
+      ySpread < 0.20 && shoulderHipDx < 0.15
+    }
+    "inverted" -> {
+      if (!anklesVisible) false
+      else hipY < shoulderY && hipY < ankleY
+    }
+    "none" -> true
+    else -> true
+  }
+}
+
   // ═══════════════════════════════════════════════════════════
   // Countdown
   // ═══════════════════════════════════════════════════════════
@@ -549,6 +664,8 @@ override fun processFrame(frame: HybridFrameSpec) {
     targetReps = 0.0
     countdownSeconds = 0.0
     frameCount = 0
+    consecutivePostureFailures = 0
+postureWasLost = false
     synchronized(landmarkLock) {
       cachedLandmarks = emptyArray()
     }

package/ios/NitroPoseExercises.swift

@@ -70,6 +70,11 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
   private var allRepDurations: [Double] = []
   private var allRepFormScores: [Double] = []
 
+  // ─── Posture Gate ──────────────────────────────────────────
+private var consecutivePostureFailures: Int = 0
+private let postureFailureThreshold: Int = 10  // ~1s at 30fps with throttle=3
+private var postureWasLost = false
+
   // ─── Pose Tracking ──────────────────────────────────────────
   private var poseWasLost = false
 
@@ -85,6 +90,8 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
   var onPoseLost: (() -> Void)?
   var onPoseRegained: (() -> Void)?
   var onSessionComplete: ((_ result: SessionResult) -> Void)?
+  var onPostureLost: (() -> Void)?
+  var onPostureRegained: (() -> Void)?
 
   // ─── Hold Tracking ──────────────────────────────────────────
   private var holdStartTime: Date?
@@ -108,6 +115,12 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
     resetSession()
   }
 
+  func isReady() throws -> Bool {
+  guard let config = exerciseConfig else { return false }
+  guard !_landmarks.isEmpty else { return false }
+  return isPostureValid(config.postureFamily)
+}
+
   // ═══════════════════════════════════════════════════════════
   // MARK: - Exercise Setup
   // ═══════════════════════════════════════════════════════════
@@ -151,12 +164,23 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
     completeSession()
   }
 
+private static func cgOrientation(orientation: CameraOrientation, isMirrored: Bool) -> CGImagePropertyOrientation {
+  switch orientation {
+  case .up:    return isMirrored ? .upMirrored    : .up
+  case .down:  return isMirrored ? .downMirrored  : .down
+  case .left:  return isMirrored ? .leftMirrored  : .left
+  case .right: return isMirrored ? .rightMirrored : .right
+  @unknown default: return .up
+  }
+}
+
   // ═══════════════════════════════════════════════════════════
   // MARK: - Frame Processing (Apple Vision)
   // ═══════════════════════════════════════════════════════════
 
   func processFrame(frame: any HybridFrameSpec) throws {
     guard _status == .active || _status == .countdown else { return }
+
     guard isInitialized else { return }
 
     // Frame throttle
@@ -173,9 +197,11 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
     // Create Vision request
     let request = VNDetectHumanBodyPoseRequest()
 
-    // Run synchronously on this frame processor thread
-    let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, options: [:])
+      print("[PoseExercise] orientation=\(frame.orientation) isMirrored=\(frame.isMirrored) type=\(type(of: frame.orientation))")
 
+      let cgOrient = Self.cgOrientation(orientation: frame.orientation, isMirrored: frame.isMirrored)
+      let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: cgOrient, options: [:])
+      
     do {
       try handler.perform([request])
 
@@ -241,13 +267,37 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
   // MARK: - Exercise Logic Engine
   // ═══════════════════════════════════════════════════════════
 
-  private func processExerciseLogic() {
-    guard let config = exerciseConfig else { return }
-    guard !_landmarks.isEmpty else { return }
+private func processExerciseLogic() {
+
+  guard let config = exerciseConfig else { return }
+  guard !_landmarks.isEmpty else { return }
+
+  // Posture gate with hysteresis
+  if !isPostureValid(family: config.postureFamily, threshold: config.visibilityThreshold) {
+    consecutivePostureFailures += 1
+    if consecutivePostureFailures >= postureFailureThreshold {
+      if !postureWasLost {
+        postureWasLost = true
+        onPostureLost?()
+      }
+      _currentPhase = .unknown
+      phaseHistory = []
+    }
+    return
+  }
+
+  consecutivePostureFailures = 0
+  
+  if postureWasLost {
+    postureWasLost = false
+    onPostureRegained?()
+  }
 
     var currentAngles: [String: Double] = [:]
     var angleSnapshots: [AngleSnapshot] = []
 
+   let visThreshold = config.visibilityThreshold
+
     for angleDef in config.angles {
       let a = Int(angleDef.landmarkA)
       let b = Int(angleDef.landmarkB)
@@ -255,10 +305,10 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
 
       guard a < _landmarks.count, b < _landmarks.count, c < _landmarks.count else { continue }
 
-      // Only calculate if all three landmarks have reasonable confidence
-      guard _landmarks[a].visibility > 0.3,
-            _landmarks[b].visibility > 0.3,
-            _landmarks[c].visibility > 0.3 else { continue }
+      guard _landmarks[a].visibility > visThreshold,
+            _landmarks[b].visibility > visThreshold,
+            _landmarks[c].visibility > visThreshold else { continue }
+
 
       let angle = calculateAngle(
         pointA: _landmarks[a],
@@ -293,6 +343,71 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
     }
   }
 
+  // ═══════════════════════════════════════════════════════════
+// MARK: - Posture Gates
+// ═══════════════════════════════════════════════════════════
+
+private func isPostureValid(_ family: String) -> Bool {
+  guard _landmarks.count >= 33 else { return false }
+
+  let ls = _landmarks[11], rs = _landmarks[12]
+  let lh = _landmarks[23], rh = _landmarks[24]
+  let lk = _landmarks[25], rk = _landmarks[26]
+  let la = _landmarks[27], ra = _landmarks[28]
+
+  let key = [ls, rs, lh, rh]
+  guard key.allSatisfy({ $0.visibility > 0.3 }) else { return false }
+
+  let shoulderY = (ls.y + rs.y) / 2
+  let hipY = (lh.y + rh.y) / 2
+  let shoulderX = (ls.x + rs.x) / 2
+  let hipX = (lh.x + rh.x) / 2
+
+  let kneesVisible = lk.visibility > 0.3 && rk.visibility > 0.3
+  let anklesVisible = la.visibility > 0.3 && ra.visibility > 0.3
+  let kneeY = kneesVisible ? (lk.y + rk.y) / 2 : hipY
+  let ankleY = anklesVisible ? (la.y + ra.y) / 2 : kneeY
+
+  switch family {
+  case "horizontalProne":
+    let ys = [shoulderY, hipY, ankleY]
+    let spread = (ys.max() ?? 0) - (ys.min() ?? 0)
+    return spread < 0.25
+
+  case "standingUpright":
+    guard kneesVisible else { return false }
+    return shoulderY < hipY - 0.08
+        && hipY < kneeY + 0.05
+        && (anklesVisible ? kneeY < ankleY : true)
+
+  case "seated":
+    guard kneesVisible else { return false }
+    return shoulderY < hipY - 0.05
+        && abs(hipY - kneeY) < 0.20
+
+  case "supine":
+    let ys = [shoulderY, hipY, ankleY]
+    let spread = (ys.max() ?? 0) - (ys.min() ?? 0)
+    return spread < 0.25
+
+  case "sidePlank":
+    let ys = [shoulderY, hipY]
+    let ySpread = (ys.max() ?? 0) - (ys.min() ?? 0)
+    let shoulderHipDx = abs(shoulderX - hipX)
+    return ySpread < 0.20 && shoulderHipDx < 0.15
+
+  case "inverted":
+    guard anklesVisible else { return false }
+    return hipY < shoulderY && hipY < ankleY
+
+  case "none":
+    return true
+
+  default:
+    return true
+  }
+}
+
   // ═══════════════════════════════════════════════════════════
   // MARK: - Angle Calculation
   // ═══════════════════════════════════════════════════════════
@@ -547,6 +662,8 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
     countdownSeconds = 0
     countdownTimer?.invalidate()
     countdownTimer = nil
-    frameCount = 0
+    frameCount = 0,
+    consecutivePostureFailures = 0
+    postureWasLost = false
   }
-}
+}

package/lib/module/NitroPoseExercises.nitro.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","nitroPoseExercises","createHybridObject"],"sourceRoot":"../../src","sources":["NitroPoseExercises.nitro.ts"],"mappings":";;AAAA,SAA4BA,YAAY,QAAQ,4BAA4B;;AAI5E;;AAUA;;AASA;;AAmCA;;AAmCA;;AAwCA,MAAMC,kBAAkB,GACtBD,YAAY,CAACE,kBAAkB,CAAqB,cAAc,CAAC;AAErE,SAASD,kBAAkB","ignoreList":[]}
+{"version":3,"names":["NitroModules","nitroPoseExercises","createHybridObject"],"sourceRoot":"../../src","sources":["NitroPoseExercises.nitro.ts"],"mappings":";;AAAA,SAA4BA,YAAY,QAAQ,4BAA4B;;AAI5E;;AAqBA;;AASA;;AAsCA;;AAmCA;;AA4CA,MAAMC,kBAAkB,GACtBD,YAAY,CAACE,kBAAkB,CAAqB,cAAc,CAAC;AAErE,SAASD,kBAAkB","ignoreList":[]}

package/lib/module/config/bicep-curl.js

@@ -7,6 +7,9 @@
 export const BICEP_CURL_CONFIG = {
   name: 'Bicep Curl',
   type: 'rep',
+  postureFamily: 'standingUpright',
+  visibilityThreshold: 0.2,
+  cameraAngle: 'front',
   angles: [{
     name: 'leftElbow',
     landmarkA: 11,

package/lib/module/config/bicep-curl.js.map

@@ -1 +1 @@
-{"version":3,"names":["BICEP_CURL_CONFIG","name","type","angles","landmarkA","landmarkB","landmarkC","phases","phase","angleName","minAngle","maxAngle","repSequence","formRules","message","severity","holdDurationMs"],"sourceRoot":"../../../src","sources":["config/bicep-curl.ts"],"mappings":";;AAEA;AACA;AACA;;AAEA,OAAO,MAAMA,iBAAiC,GAAG;EAC/CC,IAAI,EAAE,YAAY;EAClBC,IAAI,EAAE,KAAK;EACXC,MAAM,EAAE,CACN;IACEF,IAAI,EAAE,WAAW;IACjBG,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE,CAAE;EACjB,CAAC,EACD;IACEL,IAAI,EAAE,YAAY;IAClBG,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE,CAAE;EACjB,CAAC,EACD;IACEL,IAAI,EAAE,cAAc;IACpBG,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE,CAAE;EACjB,CAAC,CACF;EACDC,MAAM,EAAE,CACN;IACEC,KAAK,EAAE,MAAM;IACbC,SAAS,EAAE,WAAW;IACtBC,QAAQ,EAAE,GAAG;IACbC,QAAQ,EAAE;EACZ,CAAC,EACD;IACEH,KAAK,EAAE,IAAI;IACXC,SAAS,EAAE,WAAW;IACtBC,QAAQ,EAAE,EAAE;IACZC,QAAQ,EAAE;EACZ,CAAC,CACF;EACDC,WAAW,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC;EACnCC,SAAS,EAAE,CACT;IACEZ,IAAI,EAAE,YAAY;IAClBa,OAAO,EAAE,uCAAuC;IAChDC,QAAQ,EAAE,SAAS;IACnBN,SAAS,EAAE,cAAc;IACzBC,QAAQ,EAAE,CAAC;IACXC,QAAQ,EAAE;EACZ,CAAC,EACD;IACEV,IAAI,EAAE,UAAU;IAChBa,OAAO,EAAE,oCAAoC;IAC7CC,QAAQ,EAAE,OAAO;IACjBN,SAAS,EAAE,cAAc;IACzBC,QAAQ,EAAE,CAAC;IACXC,QAAQ,EAAE;EACZ,CAAC,CACF;EACDK,cAAc,EAAE;AAClB,CAAC","ignoreList":[]}
+{"version":3,"names":["BICEP_CURL_CONFIG","name","type","postureFamily","visibilityThreshold","cameraAngle","angles","landmarkA","landmarkB","landmarkC","phases","phase","angleName","minAngle","maxAngle","repSequence","formRules","message","severity","holdDurationMs"],"sourceRoot":"../../../src","sources":["config/bicep-curl.ts"],"mappings":";;AAEA;AACA;AACA;;AAEA,OAAO,MAAMA,iBAAiC,GAAG;EAC/CC,IAAI,EAAE,YAAY;EAClBC,IAAI,EAAE,KAAK;EACXC,aAAa,EAAE,iBAAiB;EAChCC,mBAAmB,EAAE,GAAG;EACxBC,WAAW,EAAE,OAAO;EACpBC,MAAM,EAAE,CACN;IACEL,IAAI,EAAE,WAAW;IACjBM,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE,CAAE;EACjB,CAAC,EACD;IACER,IAAI,EAAE,YAAY;IAClBM,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE,CAAE;EACjB,CAAC,EACD;IACER,IAAI,EAAE,cAAc;IACpBM,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE;IAAE;IACfC,SAAS,EAAE,EAAE,CAAE;EACjB,CAAC,CACF;EACDC,MAAM,EAAE,CACN;IACEC,KAAK,EAAE,MAAM;IACbC,SAAS,EAAE,WAAW;IACtBC,QAAQ,EAAE,GAAG;IACbC,QAAQ,EAAE;EACZ,CAAC,EACD;IACEH,KAAK,EAAE,IAAI;IACXC,SAAS,EAAE,WAAW;IACtBC,QAAQ,EAAE,EAAE;IACZC,QAAQ,EAAE;EACZ,CAAC,CACF;EACDC,WAAW,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC;EACnCC,SAAS,EAAE,CACT;IACEf,IAAI,EAAE,YAAY;IAClBgB,OAAO,EAAE,uCAAuC;IAChDC,QAAQ,EAAE,SAAS;IACnBN,SAAS,EAAE,cAAc;IACzBC,QAAQ,EAAE,CAAC;IACXC,QAAQ,EAAE;EACZ,CAAC,EACD;IACEb,IAAI,EAAE,UAAU;IAChBgB,OAAO,EAAE,oCAAoC;IAC7CC,QAAQ,EAAE,OAAO;IACjBN,SAAS,EAAE,cAAc;IACzBC,QAAQ,EAAE,CAAC;IACXC,QAAQ,EAAE;EACZ,CAAC,CACF;EACDK,cAAc,EAAE;AAClB,CAAC","ignoreList":[]}

package/lib/module/config/boat-pose.js

@@ -3,6 +3,9 @@
 export const BOAT_POSE_CONFIG = {
   name: 'Boat Pose (Navasana)',
   type: 'hold',
+  postureFamily: 'seated',
+  visibilityThreshold: 0.3,
+  cameraAngle: 'side',
   angles: [{
     name: 'hipFlexion',
     landmarkA: 11,

package/lib/module/config/boat-pose.js.map

@@ -1 +1 @@
-{"version":3,"names":["BOAT_POSE_CONFIG","name","type","angles","landmarkA","landmarkB","landmarkC","phases","phase","angleName","minAngle","maxAngle","repSequence","formRules","message","severity","holdDurationMs"],"sourceRoot":"../../../src","sources":["config/boat-pose.ts"],"mappings":";;AAEA,OAAO,MAAMA,gBAAgC,GAAG;EAC9CC,IAAI,EAAE,sBAAsB;EAC5BC,IAAI,EAAE,MAAM;EACZC,MAAM,EAAE,CACN;IAAEF,IAAI,EAAE,YAAY;IAAEG,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,EACnE;IAAEL,IAAI,EAAE,WAAW;IAAEG,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,CACnE;EACDC,MAAM,EAAE,CACN;IAAEC,KAAK,EAAE,MAAM;IAAEC,SAAS,EAAE,YAAY;IAAEC,QAAQ,EAAE,EAAE;IAAEC,QAAQ,EAAE;EAAI,CAAC,CACxE;EACDC,WAAW,EAAE,EAAE;EACfC,SAAS,EAAE,CACT;IACEZ,IAAI,EAAE,cAAc;IACpBa,OAAO,EAAE,6CAA6C;IACtDC,QAAQ,EAAE,SAAS;IACnBN,SAAS,EAAE,YAAY;IACvBC,QAAQ,EAAE,EAAE;IACZC,QAAQ,EAAE;EACZ,CAAC,EACD;IACEV,IAAI,EAAE,cAAc;IACpBa,OAAO,EAAE,uBAAuB;IAChCC,QAAQ,EAAE,SAAS;IACnBN,SAAS,EAAE,WAAW;IACtBC,QAAQ,EAAE,GAAG;IACbC,QAAQ,EAAE;EACZ,CAAC,CACF;EACDK,cAAc,EAAE;AAClB,CAAC","ignoreList":[]}
+{"version":3,"names":["BOAT_POSE_CONFIG","name","type","postureFamily","visibilityThreshold","cameraAngle","angles","landmarkA","landmarkB","landmarkC","phases","phase","angleName","minAngle","maxAngle","repSequence","formRules","message","severity","holdDurationMs"],"sourceRoot":"../../../src","sources":["config/boat-pose.ts"],"mappings":";;AAEA,OAAO,MAAMA,gBAAgC,GAAG;EAC9CC,IAAI,EAAE,sBAAsB;EAC5BC,IAAI,EAAE,MAAM;EACZC,aAAa,EAAE,QAAQ;EACvBC,mBAAmB,EAAE,GAAG;EACxBC,WAAW,EAAE,MAAM;EACnBC,MAAM,EAAE,CACN;IAAEL,IAAI,EAAE,YAAY;IAAEM,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,EACnE;IAAER,IAAI,EAAE,WAAW;IAAEM,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,CACnE;EACDC,MAAM,EAAE,CACN;IAAEC,KAAK,EAAE,MAAM;IAAEC,SAAS,EAAE,YAAY;IAAEC,QAAQ,EAAE,EAAE;IAAEC,QAAQ,EAAE;EAAI,CAAC,CACxE;EACDC,WAAW,EAAE,EAAE;EACfC,SAAS,EAAE,CACT;IACEf,IAAI,EAAE,cAAc;IACpBgB,OAAO,EAAE,6CAA6C;IACtDC,QAAQ,EAAE,SAAS;IACnBN,SAAS,EAAE,YAAY;IACvBC,QAAQ,EAAE,EAAE;IACZC,QAAQ,EAAE;EACZ,CAAC,EACD;IACEb,IAAI,EAAE,cAAc;IACpBgB,OAAO,EAAE,uBAAuB;IAChCC,QAAQ,EAAE,SAAS;IACnBN,SAAS,EAAE,WAAW;IACtBC,QAAQ,EAAE,GAAG;IACbC,QAAQ,EAAE;EACZ,CAAC,CACF;EACDK,cAAc,EAAE;AAClB,CAAC","ignoreList":[]}