@vincentt-xr/sdk 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/body-pose/index.d.ts

@@ -0,0 +1,521 @@
+import { TrackerPoint } from '../types/common';
+/** The person's side (anatomical: their own left / right, on any camera). */
+export type BodySide = "left" | "right";
+/**
+ * What one arm is doing:
+ * - `raised` — wrist clearly above the head (any angle or twist; a real full raise leans and turns)
+ * - `out` — stretched out to the side at shoulder height (a T-pose arm)
+ * - `onHead` — hand on or just above the head, elbow bent
+ * - `onHip` — hand on the hip (at the waist, above the hip line), elbow well out
+ * - `thumbUp` — a fist held up in front (elbow bent), the thumb pointing up
+ * - `crossed` — wrist across the body's midline at chest / belly height
+ * - `down` — hanging well below the shoulder
+ * - `other` — anything else (a half raise, a reach forward …)
+ */
+export type ArmState = "raised" | "out" | "onHead" | "onHip" | "thumbUp" | "crossed" | "down" | "other";
+/** MediaPipe pose landmark indices the body poses read. */
+export declare const BODY_POSE_JOINTS: {
+    readonly nose: 0;
+    readonly leftShoulder: 11;
+    readonly rightShoulder: 12;
+    readonly leftElbow: 13;
+    readonly rightElbow: 14;
+    readonly leftWrist: 15;
+    readonly rightWrist: 16;
+    /** MediaPipe's hand points on the pose: pinky and index knuckles, the thumb's second knuckle. */
+    readonly leftPinky: 17;
+    readonly rightPinky: 18;
+    readonly leftIndex: 19;
+    readonly rightIndex: 20;
+    readonly leftThumb: 21;
+    readonly rightThumb: 22;
+    readonly leftHip: 23;
+    readonly rightHip: 24;
+    readonly leftKnee: 25;
+    readonly rightKnee: 26;
+    readonly leftAnkle: 27;
+    readonly rightAnkle: 28;
+};
+/** MediaPipe pose landmarks per body (`analyzeBodyShape` needs all of them). */
+export declare const BODY_LANDMARK_COUNT = 33;
+/** Landmarks that must be visible for the upper body to count as in view. */
+export declare const BODY_UPPER_JOINTS: readonly [0, 11, 12, 13, 14, 15, 16];
+/** Landmarks that must be visible for the lower body to count as in view (hips, knees, ankles). */
+export declare const BODY_LOWER_JOINTS: readonly [23, 24, 25, 26, 27, 28];
+/**
+ * What one leg is doing:
+ * - `raised` — knee lifted toward hip height with the foot off the ground (standing on the other leg)
+ * - `down` — standing: the knee well below the hip
+ * - `other` — anything else (a squat's bent knee, a step …)
+ */
+export type LegState = "raised" | "down" | "other";
+/**
+ * The classifier's default thresholds (in shoulder widths, angles in degrees).
+ * Read-only: tune per call with `analyzeBodyShape(landmarks, { limits })` or a
+ * hook's `limits` option.
+ */
+export declare const BODY_SHAPE_LIMITS: Readonly<{
+    /** A landmark counts as visible above this. */
+    visible: 0.5;
+    /** `raised`: wrist this far above its shoulder … */
+    raisedAboveShoulder: 0.75;
+    /** `out`: wrist within this of shoulder height … */
+    outLevel: 0.5;
+    /** … reaching at least this far outward … */
+    outReach: 0.9;
+    /** … with the elbow this straight (max bend). */
+    outStraight: 45;
+    /** `onHead`: wrist above the shoulder by at least this … */
+    onHeadAboveShoulder: 0.35;
+    /** … within this of the nose sideways … */
+    onHeadNearNose: 0.8;
+    /** … not higher than this above the nose (a hand ON the head, not reaching up) … */
+    onHeadMaxAboveNose: 1.1;
+    /** … with the elbow bent at least this much. */
+    onHeadBend: 55;
+    /**
+     * `onHip`: wrist ABOVE the hip landmark by this much (at the waist; hands in
+     * pockets sit on the hip line) …
+     */
+    onHipAboveMin: 0.12;
+    /** … but not higher than this … */
+    onHipAboveMax: 0.9;
+    /** … and sideways (hip outward positive), between these … */
+    onHipInward: -0.45;
+    onHipOutward: 0.7;
+    /** … with the elbow well out past the shoulder by this … */
+    onHipElbowOut: 0.3;
+    /** … and bent at least this much. */
+    onHipBend: 45;
+    /**
+     * `thumbUp`: the thumb point at least this far above the index and pinky
+     * knuckles (a fist, thumb up — not an open hand or a thumb to the side) …
+     */
+    thumbUpLift: 0.08;
+    /** … and above the wrist by at least this … */
+    thumbUpAboveWrist: 0.12;
+    /** … with the wrist between these heights relative to the shoulder (down negative) … */
+    thumbUpTop: 0.6;
+    thumbUpBottom: -1.3;
+    /** … not reaching more than this past the midline (a hand in front of its own side). */
+    thumbUpPastMidline: 0.3;
+    /** `crossed`: wrist past the midline by this … */
+    crossedPast: 0.05;
+    /** … between these heights relative to the shoulder (down negative). */
+    crossedTop: 0.35;
+    crossedBottom: -1.9;
+    /** `down`: wrist at least this far below its shoulder. */
+    downBelow: 0.9;
+    /** Leg `raised`: knee no lower than this relative to its hip (negative = below) … */
+    legRaisedKnee: -0.6;
+    /** … and its ankle at least this far above the other ankle (the foot is off the ground). */
+    legRaisedAnkle: 0.4;
+    /** Leg `down`: knee at least this far below its hip. */
+    legDownBelow: 0.8;
+    /**
+     * `squat`: the hips at most this high above the ankles (standing ≈ 2.2, a
+     * deep squat ≈ 1.1), with both feet on the ground.
+     */
+    squatHipHeight: 1.65;
+    /** `lean`: the torso (hips → shoulders) tilted at least this far from upright, degrees. */
+    leanDegrees: 8;
+    /** `wideStance`: the ankles at least this far apart. */
+    wideStance: 1.4;
+}>;
+/** The classifier thresholds (see `BODY_SHAPE_LIMITS` for each one's meaning). */
+export type BodyShapeLimits = Record<keyof typeof BODY_SHAPE_LIMITS, number>;
+export type ArmShape = {
+    state: ArmState;
+    /** Wrist height above the shoulder, in shoulder widths. */
+    up: number;
+    /** Wrist reach away from the body's midline past the shoulder, in shoulder widths. */
+    out: number;
+    /** Elbow bend in degrees (0 = straight). */
+    bend: number;
+    /** Elbow reach away from the body past the shoulder, in shoulder widths. */
+    elbowOut: number;
+    /** Wrist height above the same-side hip landmark, in shoulder widths. */
+    aboveHip: number;
+    /**
+     * How far the thumb point rises above the higher of the index and pinky
+     * knuckles, in shoulder widths (positive for a thumbs up).
+     */
+    thumbLift: number;
+};
+export type LegShape = {
+    state: LegState;
+    /** Knee height relative to its hip, in shoulder widths (standing ≈ −1.1, knee at hip height ≈ 0). */
+    kneeLift: number;
+    /** Ankle height above the other ankle, in shoulder widths. */
+    ankleLift: number;
+    /** Knee bend in degrees (0 = straight). */
+    bend: number;
+};
+export type BodyShape = {
+    arms: Record<BodySide, ArmShape>;
+    /** Shoulder width in tracker units (the scale everything is measured in). */
+    shoulderWidth: number;
+    /** Whether the upper body (nose, shoulders, elbows, wrists) is visible. */
+    upperBodyVisible: boolean;
+    /** Whether the hips are visible (needed for `onHip` and `lean`). */
+    hipsVisible: boolean;
+    /** Whether hips, knees and ankles are visible (needed for the leg poses). */
+    lowerBodyVisible: boolean;
+    /** Each leg (`null` while the lower body is not in view). */
+    legs: Record<BodySide, LegShape> | null;
+    /**
+     * Torso tilt from upright in degrees, + toward the person's own left
+     * (`null` while the hips are not in view).
+     */
+    lean: number | null;
+    /** The side the torso leans toward past `leanDegrees`, else `null`. */
+    leanSide: BodySide | null;
+    /** Hip height above the ankles, in shoulder widths (`null` without the lower body). */
+    hipHeight: number | null;
+    /** Ankle spread, in shoulder widths (`null` without the lower body). */
+    stance: number | null;
+    /** Hips low over both feet. */
+    squat: boolean;
+    /** Feet spread wide. */
+    wideStance: boolean;
+};
+export type AnalyzeBodyShapeOptions = {
+    /**
+     * The tracker input is mirrored (the selfie webcam): MediaPipe's left / right
+     * labels then name the person's opposite side, so they are swapped. Default `false`.
+     */
+    mirrored?: boolean;
+    /** Per-landmark visibility (0..1); without it every landmark counts as visible. */
+    visibility?: readonly number[];
+    /** Thresholds to override (the rest keep `BODY_SHAPE_LIMITS`). */
+    limits?: Partial<BodyShapeLimits>;
+    /**
+     * The tracked frame's aspect ratio, width ÷ height (`useXRFeedAspect()`).
+     * Tracker x and y each span −1..1 across the frame, so on a portrait or
+     * landscape frame a unit of x is not a unit of y; the landmarks are scaled
+     * to square units first (`squareLandmarks`) so every pose reads the same on
+     * any frame. Default 1 (the landmarks are already in square units).
+     */
+    aspect?: number;
+};
+/**
+ * Landmarks in square units: x (and MediaPipe's depth z, which shares x's
+ * scale) multiplied by the frame's aspect ratio (width ÷ height), so a unit
+ * of x equals a unit of y (half the frame height). Tracker space spans the
+ * frame on each axis, so without this a horizontal distance on a portrait
+ * frame reads 1.78× too long next to a vertical one. Returns the input
+ * unchanged for a square frame (`aspect` 1).
+ */
+export declare const squareLandmarks: (landmarks: readonly TrackerPoint[], aspect?: number) => readonly TrackerPoint[];
+/**
+ * Reads each arm's state from MediaPipe pose landmarks in tracker coordinates
+ * (`BodyTracker`'s `getLandmarks2D`: x right, y up, 33 points). Scale-free
+ * (shoulder widths), side-correct (measured from the body's midline, labels
+ * swapped on a mirrored feed) and, given the frame's `aspect`, the same on
+ * portrait, landscape and square frames. Pure.
+ */
+export declare const analyzeBodyShape: (tracked: readonly TrackerPoint[], { mirrored, visibility, limits, aspect }?: AnalyzeBodyShapeOptions) => BodyShape;
+/**
+ * What a pose requires of each arm; an array means any of those states,
+ * omitted = any. `anyOf` passes when one of its rules does (a thumbs up with
+ * either hand).
+ */
+export type BodyPoseRule = {
+    arms?: Partial<Record<BodySide, ArmState | readonly ArmState[]>>;
+    /** Per leg, like `arms` (needs the lower body in view). */
+    legs?: Partial<Record<BodySide, LegState | readonly LegState[]>>;
+    /** The torso leans toward this side, or `"none"` = upright (needs the hips in view). */
+    lean?: BodySide | "none";
+    /** Hips low over both feet (`true`) or not (`false`). */
+    squat?: boolean;
+    /** Feet spread wide (`true`) or not (`false`). */
+    wideStance?: boolean;
+    anyOf?: readonly BodyPoseRule[];
+};
+/** Your own test of a body shape (any logic over the arm measurements). */
+export type BodyPoseMatch = (shape: BodyShape) => boolean;
+/** How the hint figure shows a pose. */
+export type BodyPoseHintPose = {
+    /** The hint model's animation clip that shows it (`ybot.glb` ships one per pose). */
+    clip: string;
+    /** The person's arms that make the pose (drawn brighter on the hint). Default none. */
+    arms?: readonly BodySide[];
+    /** The person's legs that make the pose (drawn brighter on the hint). Default none. */
+    legs?: readonly BodySide[];
+};
+/**
+ * A pose: its default copy, how it is detected (`rule`, or `match` for logic
+ * a rule cannot express; with both, both must pass) and how the hint figure
+ * shows it. Make your own with `defineBodyPose`.
+ */
+export type BodyPoseDefinition = {
+    /** Default instruction copy. */
+    label: string;
+    rule?: BodyPoseRule;
+    match?: BodyPoseMatch;
+    /**
+     * What the detector's `isInView` asks for (the "waiting" status and the
+     * nudge; completion only needs the rule): the upper body (default) or the
+     * whole body (the leg and lean poses).
+     */
+    view?: "upper" | "full";
+    hint: BodyPoseHintPose;
+};
+/**
+ * Anything that names a pose to detect: a built-in name, a rule, a match
+ * function or a full definition.
+ */
+export type BodyPoseSpec = BodyPoseName | BodyPoseRule | BodyPoseMatch | BodyPoseDefinition;
+/**
+ * Checks and returns your own pose definition (it needs a `rule` or a
+ * `match`). Pass it anywhere a pose name goes.
+ *
+ * ```ts
+ * const flex = defineBodyPose({
+ *   label: "Show your muscles",
+ *   rule: { arms: { left: "onHead", right: "onHead" } },
+ *   hint: { clip: "flex", arms: ["left", "right"] }, // a clip in your own figure
+ * });
+ * ```
+ */
+export declare const defineBodyPose: <T extends BodyPoseDefinition>(definition: T) => T;
+/**
+ * The body instruction vocabulary (arm poses; the upper body is enough). Left /
+ * right are the person's own sides.
+ */
+export declare const BODY_POSES: {
+    readonly hooray: {
+        readonly label: "Raise both arms";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "raised";
+                readonly right: "raised";
+            };
+        };
+        readonly hint: {
+            readonly clip: "hooray";
+            readonly arms: readonly ["left", "right"];
+        };
+    };
+    /** Alias of `hooray` (the same rule and hint): both arms raised. */
+    readonly handsUp: {
+        readonly label: "Hands up";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "raised";
+                readonly right: "raised";
+            };
+        };
+        readonly hint: {
+            readonly clip: "hooray";
+            readonly arms: readonly ["left", "right"];
+        };
+    };
+    readonly tPose: {
+        readonly label: "Make a T-pose";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "out";
+                readonly right: "out";
+            };
+        };
+        readonly hint: {
+            readonly clip: "tpose";
+            readonly arms: readonly ["left", "right"];
+        };
+    };
+    readonly raiseLeft: {
+        readonly label: "Raise your left arm";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "raised";
+                readonly right: readonly ["down", "other", "onHip"];
+            };
+            readonly lean: "none";
+        };
+        readonly hint: {
+            readonly clip: "raiseLeft";
+            readonly arms: readonly ["left"];
+        };
+    };
+    readonly raiseRight: {
+        readonly label: "Raise your right arm";
+        readonly rule: {
+            readonly arms: {
+                readonly right: "raised";
+                readonly left: readonly ["down", "other", "onHip"];
+            };
+            readonly lean: "none";
+        };
+        readonly hint: {
+            readonly clip: "raiseRight";
+            readonly arms: readonly ["right"];
+        };
+    };
+    readonly handsOnHips: {
+        readonly label: "Hands on your hips";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "onHip";
+                readonly right: "onHip";
+            };
+        };
+        readonly hint: {
+            readonly clip: "handsOnHips";
+            readonly arms: readonly ["left", "right"];
+        };
+    };
+    readonly armsCrossed: {
+        readonly label: "Cross your arms";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "crossed";
+                readonly right: "crossed";
+            };
+        };
+        readonly hint: {
+            readonly clip: "armsCrossed";
+            readonly arms: readonly ["left", "right"];
+        };
+    };
+    readonly handsOnHead: {
+        readonly label: "Hands on your head";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "onHead";
+                readonly right: "onHead";
+            };
+        };
+        readonly hint: {
+            readonly clip: "handsOnHead";
+            readonly arms: readonly ["left", "right"];
+        };
+    };
+    readonly thumbUp: {
+        readonly label: "Give a thumbs up";
+        readonly rule: {
+            readonly anyOf: readonly [{
+                readonly arms: {
+                    readonly right: "thumbUp";
+                };
+            }, {
+                readonly arms: {
+                    readonly left: "thumbUp";
+                };
+            }];
+        };
+        readonly hint: {
+            readonly clip: "thumbUp";
+            readonly arms: readonly ["right"];
+        };
+    };
+    readonly bothThumbsUp: {
+        readonly label: "Two thumbs up";
+        readonly rule: {
+            readonly arms: {
+                readonly left: "thumbUp";
+                readonly right: "thumbUp";
+            };
+        };
+        readonly hint: {
+            readonly clip: "bothThumbsUp";
+            readonly arms: readonly ["left", "right"];
+        };
+    };
+    readonly salute: {
+        readonly label: "Salute";
+        readonly rule: {
+            readonly arms: {
+                readonly right: "onHead";
+                readonly left: readonly ["down", "other", "onHip"];
+            };
+        };
+        readonly hint: {
+            readonly clip: "salute";
+            readonly arms: readonly ["right"];
+        };
+    };
+    readonly squat: {
+        readonly label: "Squat down";
+        readonly rule: {
+            readonly squat: true;
+        };
+        readonly view: "full";
+        readonly hint: {
+            readonly clip: "squat";
+            readonly arms: readonly [];
+            readonly legs: readonly ["left", "right"];
+        };
+    };
+    readonly leanLeft: {
+        readonly label: "Lean to your left";
+        readonly rule: {
+            readonly lean: "left";
+        };
+        readonly view: "full";
+        readonly hint: {
+            readonly clip: "leanLeft";
+            readonly arms: readonly ["right"];
+        };
+    };
+    readonly leanRight: {
+        readonly label: "Lean to your right";
+        readonly rule: {
+            readonly lean: "right";
+        };
+        readonly view: "full";
+        readonly hint: {
+            readonly clip: "leanRight";
+            readonly arms: readonly ["left"];
+        };
+    };
+    readonly oneLeg: {
+        readonly label: "Stand on one leg";
+        readonly rule: {
+            readonly anyOf: readonly [{
+                readonly legs: {
+                    readonly right: "raised";
+                    readonly left: "down";
+                };
+            }, {
+                readonly legs: {
+                    readonly left: "raised";
+                    readonly right: "down";
+                };
+            }];
+        };
+        readonly view: "full";
+        readonly hint: {
+            readonly clip: "oneLeg";
+            readonly arms: readonly [];
+            readonly legs: readonly ["right"];
+        };
+    };
+    readonly star: {
+        readonly label: "Make a star";
+        readonly rule: {
+            readonly wideStance: true;
+            readonly arms: {
+                readonly left: readonly ["raised", "out"];
+                readonly right: readonly ["raised", "out"];
+            };
+        };
+        readonly view: "full";
+        readonly hint: {
+            readonly clip: "star";
+            readonly arms: readonly ["left", "right"];
+            readonly legs: readonly ["left", "right"];
+        };
+    };
+};
+export type BodyPoseName = keyof typeof BODY_POSES;
+export declare const BODY_POSE_NAMES: BodyPoseName[];
+/** The full definition a spec names (`undefined` for a bare rule or match function). */
+export declare const resolveBodyPose: (pose: BodyPoseSpec) => BodyPoseDefinition | undefined;
+/**
+ * Whether a shape satisfies a pose: a name from `BODY_POSES`, a rule, a match
+ * function or a definition.
+ */
+export declare const matchBodyPose: (shape: BodyShape, pose: BodyPoseSpec) => boolean;
+/** Every named pose a shape satisfies. */
+export declare const matchingBodyPoses: (shape: BodyShape) => BodyPoseName[];

package/dist/body-trigger/__fixtures__/syntheticBody.d.ts

@@ -0,0 +1,83 @@
+import { TrackerPoint } from '../../types/common';
+export type ArmParams = {
+    /** Upper arm, from hanging down (0) out to the side (90) and up (180); negative swings across the body. */
+    upper: number;
+    /** Upper arm tilt toward the camera (90 = pointing at it). */
+    upperFwd: number;
+    /** Forearm, same convention, absolute (not relative to the upper arm). */
+    fore: number;
+    foreFwd: number;
+};
+export type LegParams = {
+    /** Thigh raised toward the camera from hanging (0) to level (90). */
+    thighFwd: number;
+    /** Thigh swung out to the side. */
+    thighOut: number;
+    /** Shin, absolute: forward tilt toward the camera (negative = foot behind, a heel kick). */
+    shinFwd: number;
+    shinOut: number;
+};
+export type BodyParams = {
+    /** Hip midpoint position in tracker units, and tracker units per metre. */
+    x: number;
+    y: number;
+    scale: number;
+    /**
+     * The frame's aspect, width ÷ height (9/16 portrait, 16/9 landscape). Tracker
+     * x spans the frame width, so it reads square-unit x ÷ aspect.
+     */
+    aspect: number;
+    /** Whole-body lift above the ground (m): a jump. */
+    lift: number;
+    /** Torso tilt toward the camera (deg). */
+    torsoFwd: number;
+    left: ArmParams;
+    right: ArmParams;
+    leftLeg: LegParams;
+    rightLeg: LegParams;
+};
+export declare const STANDING: BodyParams;
+export type SyntheticFrame = {
+    landmarks: TrackerPoint[];
+    visibility: number[];
+    mirrored: boolean;
+    /** The frame's aspect (width ÷ height), to pass on as `aspect`. */
+    aspect: number;
+};
+/**
+ * Visibility as MediaPipe reports a whole body standing in frame with the feet
+ * near the bottom edge: high on the upper body and hips, lower on the knees,
+ * and well under 0.5 on the ankles and feet.
+ */
+export declare const IN_FRAME_VISIBILITY: Record<number, number>;
+/**
+ * Visibility as MediaPipe reports a body cut off below the hips (a front camera
+ * held close): the hips borderline, the knees and ankles near 0.
+ */
+export declare const CLOSE_UP_VISIBILITY: Record<number, number>;
+export type RenderOptions = {
+    /** The selfie feed: the image flips and MediaPipe's labels follow the image. */
+    mirrored?: boolean;
+    /** Hips, knees, ankles and feet hidden (visibility 0.1): the body cut off at the waist. */
+    legsHidden?: boolean;
+    /** Visibility per landmark index to force. */
+    visibility?: Record<number, number>;
+};
+/** MediaPipe's 33 landmarks (unmirrored: the person's left on screen-right). */
+export declare const renderBody: (p: BodyParams, options?: RenderOptions) => SyntheticFrame;
+/** Deep-ish override of the standing figure (arm / leg params merge field by field). */
+export type BodyPatch = Partial<Omit<BodyParams, "left" | "right" | "leftLeg" | "rightLeg">> & {
+    left?: Partial<ArmParams>;
+    right?: Partial<ArmParams>;
+    leftLeg?: Partial<LegParams>;
+    rightLeg?: Partial<LegParams>;
+};
+export declare const pose: (patch?: BodyPatch, base?: BodyParams) => BodyParams;
+export declare const lerpBody: (a: BodyParams, b: BodyParams, t: number) => BodyParams;
+/** Keyframes `[timeMs, params]` sampled every `stepMs` (30 fps by default), smooth in between. */
+export declare const timeline: (keys: ReadonlyArray<readonly [number, BodyParams]>, stepMs?: number) => Array<{
+    t: number;
+    body: BodyParams;
+}>;
+/** Move every keyframe: `x` / `y` add to the figure's own offsets, `scale` / `aspect` replace. */
+export declare const placed: (keys: ReadonlyArray<readonly [number, BodyParams]>, { x, y, ...rest }: Partial<Pick<BodyParams, "x" | "y" | "scale" | "aspect">>) => Array<[number, BodyParams]>;

package/dist/body-trigger/frame.d.ts

@@ -0,0 +1,88 @@
+import { BodyShape, BodyShapeLimits, BodySide } from '../body-pose';
+import { TrackerPoint } from '../types/common';
+/** The joints a move reads, named by the person's OWN side. */
+export type BodyMoveJointName = "nose" | "leftShoulder" | "rightShoulder" | "leftElbow" | "rightElbow" | "leftWrist" | "rightWrist" | "leftIndex" | "rightIndex" | "leftHip" | "rightHip" | "leftKnee" | "rightKnee" | "leftAnkle" | "rightAnkle";
+/**
+ * When a joint counts as in view for the moves. MediaPipe's visibility for an
+ * ankle in frame is often well below 0.5 (0.2 to 0.5 is common for feet near
+ * the bottom edge), while a joint outside the frame (legs cut off by a close
+ * front camera) drops near 0 and sits well past the edge; a low visibility bar
+ * plus a position check separates the two.
+ */
+export declare const BODY_MOVE_VIEW_LIMITS: Readonly<{
+    /** MediaPipe visibility at or above which a joint counts. */
+    visible: 0.2;
+    /**
+     * How far past the frame edge a joint may sit (frame units: each axis spans
+     * −1..1), so an ankle right at the edge, feet partly cropped, still counts.
+     */
+    edge: 0.12;
+}>;
+/** The in-view thresholds (see `BODY_MOVE_VIEW_LIMITS`). */
+export type BodyMoveViewLimits = Record<keyof typeof BODY_MOVE_VIEW_LIMITS, number>;
+/**
+ * One analysed tracker sample of one body, shared by every trigger that reads
+ * it: BodyInstruction's `analyzeBodyShape` result plus the person-side joints
+ * and the scales the moves measure in. Left / right are the person's OWN
+ * sides on every camera (MediaPipe's labels are swapped on a mirrored feed).
+ * Joints are in square tracker units: x right, y up, `z` toward the camera
+ * (MediaPipe's relative depth), with x and z multiplied by the frame's aspect
+ * so a unit of x equals a unit of y on any frame.
+ */
+export type BodyMoveFrame = {
+    /** BodyInstruction's analysis of the same landmarks (arm / leg states, squat, lean …). */
+    shape: BodyShape;
+    /** The landmarks as tracked (MediaPipe's labels; frame units, each axis spans −1..1). */
+    landmarks: readonly TrackerPoint[];
+    /** The person's own joints, in square units (`joints.leftWrist` is their left wrist). */
+    joints: Record<BodyMoveJointName, TrackerPoint>;
+    /** Each joint's MediaPipe visibility (1 when the source gives none). */
+    visibility: Record<BodyMoveJointName, number>;
+    /**
+     * Whether each joint is in view: visibility at least
+     * `BODY_MOVE_VIEW_LIMITS.visible` and no further than `edge` past the frame edge.
+     */
+    seen: Record<BodyMoveJointName, boolean>;
+    /** Shoulder width in square units (= `shape.shoulderWidth`): the scale of the arm moves. */
+    shoulderWidth: number;
+    /**
+     * Torso length, shoulder midpoint to hip midpoint, measured vertically: the
+     * scale of the leg moves (vertical against vertical). 0 when the hips are
+     * not below the shoulders.
+     */
+    torso: number;
+    /** Tracker-x direction of the person's own left: +1 on an unmirrored camera, −1 on the selfie feed. */
+    leftward: 1 | -1;
+    /** Shoulders, elbows and wrists are in view (`seen`). */
+    upperInView: boolean;
+    /** Shoulders, hips, knees and ankles are in view (`seen`): the leg moves need it. */
+    fullInView: boolean;
+    /** The input was a mirrored (selfie) feed. */
+    mirrored: boolean;
+    /** The frame's aspect ratio (width ÷ height) the joints were squared with. */
+    aspect: number;
+};
+export type CreateBodyMoveFrameOptions = {
+    /** The tracker input is mirrored (the selfie webcam). Default `false`. */
+    mirrored?: boolean;
+    /** Per-landmark visibility (0..1); without it every landmark counts as visible. */
+    visibility?: readonly number[];
+    /** BodyInstruction classifier thresholds to override (see `BODY_SHAPE_LIMITS`). */
+    limits?: Partial<BodyShapeLimits>;
+    /** The tracked frame's aspect ratio, width ÷ height (`useXRFeedAspect()`). Default 1. */
+    aspect?: number;
+    /** When a joint counts as in view (see `BODY_MOVE_VIEW_LIMITS`). */
+    view?: Partial<BodyMoveViewLimits>;
+};
+/**
+ * Analyses one tracker sample of one body for the body triggers. Pure; needs
+ * all 33 MediaPipe pose landmarks (`BODY_LANDMARK_COUNT`), else it throws
+ * (like `analyzeBodyShape`).
+ */
+export declare const createBodyMoveFrame: (landmarks: readonly TrackerPoint[], { mirrored, visibility, limits, aspect, view }?: CreateBodyMoveFrameOptions) => BodyMoveFrame;
+type LimbJoint = "Shoulder" | "Elbow" | "Wrist" | "Index" | "Hip" | "Knee" | "Ankle";
+/** `"leftWrist"` for `("left", "Wrist")`: the person's own joint on that side. */
+export declare const sideJoint: (side: BodySide, joint: LimbJoint) => BodyMoveJointName;
+/** Whether the arm on that side (shoulder, elbow, wrist) is seen. */
+export declare const armInView: (frame: BodyMoveFrame, side: BodySide) => boolean;
+export {};