Using your exercise JSON

{
  "schema": 1,
  "generator": "Markerless AI",
  "exercise": {
    "id": "bicep_curl",           // file name to load, and the CustomExercise id
    "name": "Bicep Curl",
    "description": "Custom exercise created with Markerless AI"
  },
  "angle_convention": "degrees, clockwise; min > max wraps through 0°",

  // How to reproduce every angle from raw keypoints, on any pose engine.
  "angle_definitions": {
    "method": "The directed angle at the vertex keypoint, swept clockwise …",
    "joints": {
      "shoulder": { "from": "elbow",    "vertex": "shoulder", "to": "hip" },
      "elbow":    { "from": "shoulder", "vertex": "elbow",    "to": "wrist" },
      "hip":      { "from": "shoulder", "vertex": "hip",      "to": "knee" },
      "knee":     { "from": "hip",      "vertex": "knee",     "to": "ankle" }
    }
  },

  "options": { "tolerance": 20, "either_side": false },

  // Only the joints your stages constrain — these become requiredFeatures.
  "required_joints": [{ "joint": "elbow", "side": "left" }],

  // The keypoints a pose engine must provide to run this file.
  "required_keypoints": ["left_shoulder", "left_elbow", "left_wrist"],

  "stages": [
    {
      "id": "stage_1",            // positional; corrections point at these
      "name": "Extended",
      "description": "Extended",
      "requirements": [
        {
          "joint": "elbow",       // shoulder | elbow | hip | knee
          "side": "left",         // left | right
          "min": 154,             // inclusive, degrees
          "max": 194,
          "captured": 174         // the angle Markerless measured, before tolerance
        }
      ]
      // "alternative_requirements": [[ ... ]]  — only when Either side is on
    }
  ],

  "corrections": [
    {
      "id": "…",
      "stage_id": "stage_2",      // which stage this fault belongs to
      "name": "Elbow drifting forward",
      "message": "Keep your elbow tucked in",
      "requirements": [ /* the WRONG pose, same shape as a stage */ ]
    }
  ]
}

export type Point = { x: number; y: number };

/** Directed angle at `vertex`, swept clockwise on screen from `from` to `to`, 0–360°. */
export function sweep(from: Point, vertex: Point, to: Point): number {
  const ux = from.x - vertex.x, uy = from.y - vertex.y;
  const vx = to.x - vertex.x, vy = to.y - vertex.y;
  const deg = (Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy) * 180) / Math.PI;
  return deg < 0 ? deg + 360 : deg;
}

// The three keypoints behind each angle — all on the same side.
// Also in the file itself, under angle_definitions.joints.
export const ANGLES = {
  shoulder: ["elbow", "shoulder", "hip"],
  elbow: ["shoulder", "elbow", "wrist"],
  hip: ["shoulder", "hip", "knee"],
  knee: ["hip", "knee", "ankle"],
} as const;

/** `keypoints` in PIXELS, y pointing down, keyed "left_elbow", "right_knee", … */
export function jointAngles(keypoints: Record<string, Point>): Record<string, number> {
  const out: Record<string, number> = {};
  for (const side of ["left", "right"]) {
    for (const [joint, names] of Object.entries(ANGLES)) {
      const [a, b, c] = names.map((n) => keypoints[`${side}_${n}`]);
      if (a && b && c) out[`${side}_${joint}`] = sweep(a, b, c);
    }
  }
  return out;
}

// The parts of the exported file the counter reads.
export type Requirement = { joint: string; side: string; min: number; max: number };
export type Stage = { id: string; name: string; requirements: Requirement[]; alternative_requirements?: Requirement[][] };
export type Correction = { stage_id: string | null; name: string; message: string; requirements: Requirement[] };
export type Exercise = { schema: number; stages: Stage[]; corrections: Correction[]; required_keypoints?: string[] };

// min > max means the band wraps through 0°, e.g. 340–20.
const inBand = (angle: number, r: Requirement) =>
  r.min > r.max ? angle >= r.min || angle <= r.max : angle >= r.min && angle <= r.max;

const meets = (reqs: Requirement[], angles: Record<string, number>) =>
  reqs.every((r) => {
    const angle = angles[`${r.side}_${r.joint}`];
    return angle !== undefined && inBand(angle, r);
  });

export class RepCounter {
  reps = 0;
  private exercise: Exercise;
  private waitingFor = 0; // index of the stage we need next
  private holding = false; // still in the stage we just matched

  constructor(exercise: Exercise) {
    this.exercise = exercise;
  }

  /** Name of the stage the counter is waiting for — handy while testing. */
  get stageWaitingFor(): string {
    return this.exercise.stages[this.waitingFor].name;
  }

  /** Call once per frame. Returns the running rep count. */
  update(angles: Record<string, number>): number {
    const stage = this.exercise.stages[this.waitingFor];
    const met =
      meets(stage.requirements, angles) ||
      (stage.alternative_requirements ?? []).some((alt) => meets(alt, angles));

    if (!met) {
      this.holding = false;
    } else if (!this.holding) {
      this.holding = true;
      this.waitingFor = (this.waitingFor + 1) % this.exercise.stages.length;
      if (this.waitingFor === 0) this.reps += 1; // meeting the last stage completes a rep
    }
    return this.reps;
  }

  /** The first fault the pose matches, if any — show its `message` as the cue. */
  fault(angles: Record<string, number>): Correction | undefined {
    return this.exercise.corrections.find((c) => c.requirements.length > 0 && meets(c.requirements, angles));
  }
}

// Once, with the exported file — bundled, or fetched from your server:
const counter = new RepCounter(loadExercise(json));

// Then per frame, with your engine's keypoints converted to pixels:
const angles = jointAngles(keypoints);
const reps = counter.update(angles);
const cue = counter.fault(angles)?.message;

// Fetch exercises instead of bundling them, and you can add or retune
// movements without shipping an app release.
let data = try await URLSession.shared.data(from: exerciseURL).0
let loaded = try QuickPoseTrain.load(data: data)

import QuickPoseCore

// Once, when the exercise screen appears:
let loaded = try QuickPoseTrain.load(named: "bicep_curl")
let engine = CustomExerciseEngine(exercise: loaded.exercise)

// `exerciseDefinition` is the SDK `Exercise`, built from the joints your
// stages actually constrain. Hand it to QuickPose exactly as you do today.
let definition = loaded.exercise.exerciseDefinition

// In your per-frame callback, where `features` is the
// [QuickPose.Feature: QuickPose.FeatureResult] dictionary QuickPose gives you:
let reps = engine.processFrame(features: features)

// The engine also publishes these, so SwiftUI updates on its own:
//   engine.currentReps       Int
//   engine.currentStage      String   — name of the stage being waited on
//   engine.feedbackMessage   String   — empty when hideFeedback is true
//   engine.incorrectJoints   Set<JointType>
//   engine.newRepCompleted   Bool

// Faults you defined in Markerless come back alongside the exercise.
let angles = QuickPoseTrain.angles(from: features)

if let fault = loaded.corrections.first(where: { $0.matches(angles) }) {
    cue = fault.message      // e.g. "Keep your elbow tucked in"
} else {
    cue = nil
}

val json = context.assets.open("bicep_curl.json").bufferedReader().use { it.readText() }
val exercise = MarkerlessExercise.parse(json)
val counter = MarkerlessRepCounter(exercise)

quickPose.start(QuickPoseAngles.features(exercise), onStart = {}) { status, overlay, features, feedback, landmarks ->
    val angles = QuickPoseAngles.from(features)
    val reps = counter.update(angles)
    val cue = counter.fault(angles)?.message
}