@fabi-play/motion 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,76 @@
+Fabi Play Kit License
+Version 1.0 (DRAFT, not yet reviewed by a lawyer)
+
+Copyright (c) 2026 Fabi Play. All rights reserved.
+
+This license applies to the Fabi Play Kit: the packages @fabi-play/protocol, @fabi-play/motion,
+@fabi-play/avatars, @fabi-play/sdk and @fabi-play/engine, in source and built form, as published on npm, served
+from https://cdn.fabiplay.app or found in this repository, including their code, type declarations, documentation,
+avatar artwork and other assets (together, the "Kit").
+
+1. Free of charge, for Fabi Play only
+
+   Fabi Play grants you a worldwide, non-exclusive, non-transferable, non-sublicensable, royalty-free license to
+   use, copy, and modify the Kit, and to distribute it as part of a Permitted Work, solely to make, test, run and
+   distribute Permitted Works.
+
+   A "Permitted Work" is a game, tool, or other software made to run on, be published on, or support the
+   development of games for the Fabi Play platform (https://fabiplay.app), including games submitted to Fabi Play
+   and tools used to build, test or preview them.
+
+2. What is not allowed
+
+   You may not, without Fabi Play's prior written permission:
+
+   a. use the Kit, or any part or modified version of it, in software that is not a Permitted Work, including in
+      any other game platform, product or service;
+   b. distribute the Kit, or a modified version of it, on its own or as a library, SDK, engine or framework for
+      others to build with, other than as part of a Permitted Work (installing it from npm or loading it from
+      https://cdn.fabiplay.app is not a distribution by you);
+   c. sell, rent or sublicense the Kit itself;
+   d. remove or alter this license, copyright notices, or the license banners in the built files;
+   e. use the avatars, the mascot "Fabi", or the name, logos or other trademarks of Fabi Play, except as the Kit
+      does when it runs inside a Permitted Work. This license grants no trademark rights;
+   f. use the Kit to circumvent, interfere with or misrepresent the Fabi Play platform, its safety, privacy or
+      parental controls, or its rules for games.
+
+3. Visible, not open source
+
+   The Kit's code is published so that developers can read it, debug with it and build Permitted Works. Being
+   visible does not make it open source; no rights are granted beyond those stated here.
+
+4. Your works
+
+   You keep all rights in your own code and content. This license does not give Fabi Play any rights in your
+   Permitted Works; publishing a game on Fabi Play is governed by Fabi Play's separate developer terms.
+
+5. Feedback
+
+   If you send Fabi Play suggestions or changes for the Kit, Fabi Play may use them without obligation to you.
+
+6. Termination
+
+   This license ends automatically if you break its terms. If you fix the breach within 30 days of becoming aware
+   of it, the license is reinstated, unless Fabi Play has already told you in writing that it is terminated. On
+   termination you must stop using and distributing the Kit. Permitted Works already distributed to end users in
+   compliance with this license may continue to be used by those end users.
+
+7. No warranty
+
+   THE KIT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+   WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+
+8. Limitation of liability
+
+   TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL FABI PLAY OR ITS CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE KIT OR THE USE OR OTHER DEALINGS IN THE KIT.
+
+9. Changes to this license
+
+   Fabi Play may publish new versions of this license. Each version of the Kit is governed by the license version
+   it is distributed with, unless you choose to accept a later version.
+
+10. Contact
+
+   For permissions beyond this license: https://fabiplay.app

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# @fabi-play/motion
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Body movements from pose landmarks, as [Fabi Play](https://fabiplay.app) reads them: jumps, squats, claps, shapes
+(arms up, T, V, star), lanes, freezing, the distance from the screen, and hands as pointers.
+
+```sh
+npm install @fabi-play/motion
+```
+
+```ts
+import { MotionTracker, shapeOf, hands } from '@fabi-play/motion'
+import type { Body } from '@fabi-play/protocol'
+
+declare const body: Body // 33 landmarks × (x, y, visibility), in player space
+const shape = shapeOf(body) // 'star', 'arms-up', … or null
+const { left, right } = hands(body)
+```
+
+Games get these movements as events from [`@fabi-play/sdk`](https://www.npmjs.com/package/@fabi-play/sdk); this
+package is for tools and for the Fabi Play apps. ESM only, types included; depends on `@fabi-play/protocol`.
+Docs: https://docs.fabiplay.app.
+
+## License
+
+Fabi Play Kit License: free to use, for making games and tools for Fabi Play only. See [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,403 @@
+// @fabi-play/motion: Body movements from pose landmarks: jumps, squats, shapes, lanes, freezing, hands as pointers. See https://docs.fabiplay.app.
+// Generated by scripts/build-lib.mjs (fabiplay-kit) from the sources: do not edit.
+
+import { AgeRange, Body as Body$1, Fov, Gesture, Point, Shape, Zone } from '@fabi-play/protocol';
+
+/** Every coefficient of the distances, in one place (see the sources above). */
+export declare const DISTANCE: {
+	/** The closest the eyes should be: this many diagonals (between THX's 1.2 and SMPTE's 1.6). */
+	readonly eyeMinPerDiagonal: 1.5;
+	/** The farthest the screen stays readable: this many diagonals. */
+	readonly readMaxPerDiagonal: 3;
+	/** The farthest the camera tracks reliably, metres (BlazePose's 2–4 m). */
+	readonly trackingMaxM: 4;
+	/** The camera must see the whole body plus this much (feet and raised hands, a jump). */
+	readonly cameraMargin: 1.15;
+	/** When the screen is too small for both (a tablet), the zone starts where the camera sees everyone and is this deep, metres. */
+	readonly smallScreenDepthM: 0.5;
+	/** Typical heights of each age band, metres (WHO, median at the band's middle). */
+	readonly heightM: Record<AgeRange, number>;
+	/** Field of view across the long side of the image when the phone can't say (the web phone), degrees. */
+	readonly defaultFovLongDeg: 65;
+	/** Where the landmarks are, as fractions of stature from the floor (children). */
+	readonly eyes: 0.91;
+	readonly nose: 0.885;
+	readonly ankles: 0.04;
+	/** Shoulders to hips (midpoints), as a fraction of stature. */
+	readonly torso: 0.29;
+	/** Shoulder to shoulder, as a fraction of stature. */
+	readonly shoulders: 0.22;
+	/**
+	 * The feet are doubted (taken as out of the picture) when the torso puts the child nearer than this fraction of
+	 * what the eyes-to-ankles span says: the two agree within a few per cent on a whole body.
+	 */
+	readonly feetDoubt: 0.75;
+	/** A landmark counts as seen from this visibility. */
+	readonly visible: 0.5;
+};
+/**
+ * The field of view of the image a phone sends, from its sensor's (degrees across the long and the short side) and
+ * the image's aspect (width / height, upright: below 1 when the phone stands upright). The image is the largest
+ * centred crop of the sensor with its aspect; upright, the long side is the height.
+ */
+export declare function imageFov(sensor: {
+	long: number;
+	short: number;
+}, aspect: number): Fov;
+/** A 4:3 sensor whose long side sees longDeg. */
+export declare function sensorFromLong(longDeg: number): {
+	long: number;
+	short: number;
+};
+/** The field of view to assume for an image of this aspect when the phone didn't send one (DEFAULT_FOV). */
+export declare const defaultFov: (aspect: number) => Fov;
+/** The tallest typical child among these bands (the tallest band when none). */
+export declare const tallestHeight: (ranges: readonly AgeRange[]) => number;
+export interface ZoneDetail extends Zone {
+	/** The eyes' minimum: DISTANCE.eyeMinPerDiagonal diagonals. */
+	eyeMin: number;
+	/** Where the camera sees the whole body with its margin. */
+	cameraMin: number;
+	/** The readability maximum: DISTANCE.readMaxPerDiagonal diagonals. */
+	readMax: number;
+	/** The screen is too small for both (max < min): the zone is where the camera sees everyone, smallScreenDepthM deep. */
+	small: boolean;
+}
+/**
+ * The green zone, metres from the screen: min = max(eyes' minimum, camera's minimum), max = min(readability maximum,
+ * tracking limit). When max < min (a tablet), [cameraMin, cameraMin + 0.5 m]. heightM: the tallest child playing
+ * (DISTANCE.heightM of the tallest band by default).
+ */
+export declare function zoneFor(o: {
+	inches: number;
+	fovV: number;
+	heightM?: number;
+}): ZoneDetail;
+export type DistanceSource = "body" | "torso" | "shoulders";
+export interface DistanceEstimate {
+	/** Metres from the camera; null when the body gives nothing to measure. */
+	distance: number | null;
+	/** What it was measured on: the whole body (head to ankles), the torso, or the shoulders' width (the closest). */
+	source: DistanceSource | null;
+	/** The feet are not seen: the camera does not see the whole child (ask them to step back). */
+	partial: boolean;
+}
+/**
+ * One body's distance from the camera, metres. fov: the image's (degrees); ageRange: the child's band, for their
+ * typical height. Measured on the span from the eyes (or the nose) to the ankles when both feet are seen in the image,
+ * else on the torso (shoulders to hips), else on the shoulders' width; partial when the feet are not seen.
+ */
+export declare function estimateDistance(body: Body$1, fov: Fov, ageRange: AgeRange): DistanceEstimate;
+/** Where a child stands against the zone: nearer than its minimum, in it, farther than its maximum; unknown when not seen. */
+export type ZonePlace = "near" | "in" | "far" | "unknown";
+export interface DistanceTrackerOptions {
+	/** The median is over this much time, ms. */
+	windowMs?: number;
+	/**
+	 * Half the hysteresis band, metres: a child enters "near" below min − margin and leaves it above min + margin (and
+	 * the same at max). Larger when the field of view is a guess (the web phone).
+	 */
+	margin?: number;
+	/** A child not seen for this long is unknown, ms. */
+	forgetMs?: number;
+}
+export interface DistanceReading {
+	/** The smoothed distance, metres, or null when unknown. */
+	distance: number | null;
+	place: ZonePlace;
+	/** The feet are not seen: ask the child to step back. */
+	partial: boolean;
+}
+/**
+ * One child's distance over time: the median of the estimates of the last windowMs, and their place against the
+ * zone with hysteresis.
+ */
+export declare class DistanceTracker {
+	private readonly samples;
+	private placeNow;
+	private lastSeen;
+	private partialNow;
+	private readonly windowMs;
+	private readonly margin;
+	private readonly forgetMs;
+	constructor(o?: DistanceTrackerOptions);
+	/** A frame: this child's estimate (null: not seen), against the zone. */
+	update(estimate: DistanceEstimate | null, zone: Zone, now: number): DistanceReading;
+	reset(): void;
+}
+/** What the guard says: nothing, a small warning (option off), or the game paused. */
+export type GuardState = "ok" | "warn" | "paused";
+export interface TooCloseOptions {
+	/** Pause the game (the grown-up's option, on by default); off: only warn. */
+	pause?: boolean;
+	/** Too close for this long, and the game pauses (or the warning shows), ms. */
+	enterMs?: number;
+	/** Every child back for this long, and the game resumes, ms. */
+	resumeMs?: number;
+	/**
+	 * A child near who then can't be measured (walking up to the screen: the feet, then the hips, then the shoulders
+	 * leave the picture) still counts as near for this long, ms: their 2 s go on.
+	 */
+	lostMs?: number;
+}
+export interface GuardResult {
+	state: GuardState;
+	/** The slots (0-based) too close now, for the overlay's names and avatars (while paused: also those not back yet). */
+	who: number[];
+	/** state changed with this update. */
+	changed: boolean;
+}
+/**
+ * The play-time rule. Each update gets, per playing child (slot), their place against the zone. A child "near" for
+ * enterMs straight makes it 'paused' (option on) or 'warn' (option off); a child near and then not measurable any
+ * more (too close for the camera to see enough of them) stays near for lostMs. 'paused' holds until every child has been
+ * seen and not near for resumeMs (an unknown child keeps it paused: the camera may not see someone right in front
+ * of it); 'warn' goes as soon as nobody is near.
+ */
+export declare class TooCloseGuard {
+	private nearSince;
+	/** Since when each child near before is not measurable any more (see lostMs). */
+	private lostSince;
+	private clearSince;
+	private stateNow;
+	private pause;
+	private readonly enterMs;
+	private readonly resumeMs;
+	private readonly lostMs;
+	constructor(o?: TooCloseOptions);
+	get state(): GuardState;
+	/** The grown-up's option changed: a pause in progress becomes a warning (off), or a warning a pause (on). */
+	setPause(pause: boolean): void;
+	update(places: readonly ZonePlace[], now: number): GuardResult;
+	/** Back to nothing (a new game, a grown-up's resume): the times start again. */
+	reset(): void;
+	private result;
+}
+/** What the bubble over a child says in calibration. */
+export type ZoneAdvice = "two-steps-back" | "step-back" | "come-closer" | "perfect" | "none";
+/**
+ * The advice for a child: two steps back when more than 0.6 m too close (a child's step is about 0.4–0.5 m), one
+ * step back when too close or the feet are not seen, closer when too far, perfect in the zone.
+ */
+export declare function zoneAdvice(reading: DistanceReading, zone: Zone): ZoneAdvice;
+/**
+ * A body as a camera would see a child of heightM standing distance metres away (for tests, the simulator and the
+ * calibration harness): standing straight, arms down, centred at x (0–1 of the image), the camera at 0.6 m looking
+ * level. Points outside the image get visibility 0, as the pose model would not see them.
+ */
+export declare function bodyAtDistance(o: {
+	heightM: number;
+	distance: number;
+	fov: Fov;
+	x?: number;
+}): Body$1;
+/**
+ * Any body (a puppet's, in the simulator) moved to look distance metres away: scaled about the point at the camera's
+ * height so the span from the eyes to the ankles is what a child of heightM shows there, its x kept. Points pushed out
+ * of the image get visibility 0. The body's own feet and eyes must be in it; otherwise it is returned as is.
+ * reference: the same child standing still, to scale by (so a jump or a squat still moves the body).
+ */
+export declare function placeAtDistance(body: Body$1, o: {
+	heightM: number;
+	distance: number;
+	fov: Fov;
+	reference?: Body$1;
+}): Body$1;
+export interface Landmark extends Point {
+	visibility: number;
+}
+export declare const landmark: (body: Body$1, i: number) => Landmark;
+/** The landmarks the movements are read from. */
+export declare function skeleton(body: Body$1): {
+	shoulders: Point;
+	hips: Point;
+	ankles: Point;
+	torso: number;
+	shoulderWidth: number;
+	nose: Landmark;
+	leftShoulder: Landmark;
+	rightShoulder: Landmark;
+	leftElbow: Landmark;
+	rightElbow: Landmark;
+	leftWrist: Landmark;
+	rightWrist: Landmark;
+	leftHip: Landmark;
+	rightHip: Landmark;
+	leftAnkle: Landmark;
+	rightAnkle: Landmark;
+};
+export type Skeleton = ReturnType<typeof skeleton>;
+/** The shape the arms (and legs) make, or null when it's none of them. */
+export declare function shapeOf(body: Body$1): Shape | null;
+/**
+ * Arms crossed in an X in front of the chest: Fabi Play's system gesture (held 1.5 s: pause, exit), reserved, so
+ * games never get it as a move. In player space, mirrored: the child's left shoulder is on the left of the image, so
+ * crossing means the left wrist past the midline towards the right shoulder and the right wrist towards the left.
+ * The side is read from the shoulders, not assumed. Measured in torsos (shoulders to hips; estimated from the
+ * shoulders when the hips are out of view).
+ */
+export declare function armsCrossed(body: Body$1): boolean;
+/** The thresholds of armsCrossed, in torsos (t: shoulders to hips). */
+export declare const CROSS: {
+	/** Each wrist at least this far past the midline (between the shoulders)… */
+	readonly past: 0.12;
+	/** …and no farther than the opposite shoulder plus this. */
+	readonly pastShoulder: 0.1;
+	/** Each elbow at least this far from the midline, on its own side. */
+	readonly elbowOut: 0.35;
+	/** Wrists between this far above the shoulder line… */
+	readonly above: 0.35;
+	/** …and this far below it (mid-chest). */
+	readonly below: 0.6;
+	/** Each wrist at least this far above its own elbow (the forearm rises)… */
+	readonly rise: 0.2;
+	/** …and this far above the other arm's elbow. */
+	readonly overElbow: 0.15;
+	/** Elbows no higher than this above the shoulder line (arms crossed over the head are not it)… */
+	readonly elbowAbove: 0.1;
+	/** …and no lower than this below the hip line. */
+	readonly elbowBelowHips: 0.3;
+	/** Shoulders at least this wide: facing the camera. */
+	readonly minShoulderWidth: 0.3;
+	/** Shoulder width over torso, to estimate the torso when the hips are out of view. */
+	readonly shoulderPerTorso: 0.8;
+};
+/**
+ * Something held for a while: progress 0–1 while active, fires once when full. Brief drop-outs (under graceMs, e.g.
+ * a frame where the pose model loses a wrist) don't reset it. After firing it is spent (progress 0, never fires) until
+ * `active` has been false for longer than graceMs, so holding on doesn't fire again.
+ */
+export declare class Hold {
+	readonly ms: number;
+	readonly graceMs: number;
+	private start;
+	private lastActive;
+	private progress;
+	private spent;
+	constructor(ms?: number, graceMs?: number);
+	update(active: boolean, now: number): {
+		progress: number;
+		fired: boolean;
+	};
+	reset(): void;
+}
+/**
+ * Staying on a target (a cursor on a button): progress 0–1 on the current target, restarts from 0 when the target
+ * changes (null: none), fires the target once per stay. After firing, progress is 0 until the target changes.
+ * Targets are compared with ===.
+ */
+export declare class Dwell<T> {
+	readonly ms: number;
+	private target;
+	private start;
+	private spent;
+	constructor(ms?: number);
+	update(target: T | null, now: number): {
+		target: T | null;
+		progress: number;
+		fired: T | null;
+	};
+	reset(): void;
+}
+/** A raised hand: the wrist above its shoulder's line, or at least this many torsos above its elbow. */
+export declare const RAISED = 0.4;
+/**
+ * The hand used as a cursor in menus: the clearly raised hand (wrist above the shoulder line, or at least RAISED
+ * torsos above its elbow; the higher wrist if both are), mapped with handSpace to the whole screen (0–1, clamped).
+ * Hands at the chest or holding a toy are not raised. Null when no hand is raised, and while the arms are crossed
+ * (the system gesture must not also press a button).
+ *
+ * The wrist on the shoulder line is at y ≈ 0.53 of the screen (handSpace): lower targets need the forearm upright.
+ */
+export declare function menuPointer(body: Body$1): Point | null;
+export type Placement = "no-body" | "too-close" | "too-far" | "go-left" | "go-right" | "ok";
+/**
+ * Whether the child stands in the circle on the screen: whole body in frame, at the right distance, near the
+ * centre. "go-left"/"go-right" are as the child sees the mirror.
+ */
+export declare function placement(body: Body$1 | null, center?: number, radius?: number): Placement;
+/**
+ * The hands as pointers on the screen (0–1): the space the arms reach, around the shoulders, stretched to the
+ * whole screen, so a child reaches every corner without walking.
+ */
+export declare function hands(body: Body$1): {
+	left: Point | null;
+	right: Point | null;
+};
+/**
+ * The same stretch as hands(), for any point of the body: a game drawing the body with it finds the wrists right
+ * under the hand pointers. Not clamped: legs go below the screen.
+ */
+export declare function handSpace(body: Body$1): (p: Point) => Point;
+export interface TrackerOptions {
+	/** Where the child stands when in the middle lane (the circle's centre). */
+	center?: number;
+}
+/**
+ * Turns a stream of bodies of one player into movements. Keeps what it needs: where the hips are when standing,
+ * whether the child is in the air, crouched, still.
+ */
+export declare class MotionTracker {
+	private hipBase;
+	private ankleBase;
+	private airborne;
+	private crouched;
+	private lane;
+	private clapOpen;
+	private last;
+	private energy;
+	private stillSince;
+	private frozen;
+	private smooth;
+	/** The body update() read and its skeleton, so hands() on the same frame reuses it (once). */
+	private read;
+	private readonly center;
+	constructor(options?: TrackerOptions);
+	/** The current lane: -1 left, 0 middle, 1 right. */
+	get currentLane(): 0 | 1 | -1;
+	/** One frame; t in ms. Returns the movements that started in it. */
+	update(body: Body$1, t: number): Gesture[];
+	/** The hands as pointers, smoothed so they don't tremble. */
+	hands(body: Body$1): {
+		left: Point | null;
+		right: Point | null;
+	};
+}
+export interface BodyTrackerOptions {
+	/**
+	 * The farthest a player's body may move between two frames and still be the same child, in torsos (shoulders to
+	 * hips). Default 1.5.
+	 */
+	maxJump?: number;
+}
+/**
+ * Who is who across frames: the pose model lists the bodies in no fixed order, so each body is matched to the
+ * player it was in the previous frame (the nearest shoulder/hip midpoint, within maxJump). Names, avatars, scores
+ * then stay with the child when children swap places or one leaves the frame and comes back.
+ *
+ * - The first assignment, and any after all players were lost, is left to right (as calibration lays the circles).
+ * - A player missing from a frame is null; when a body shows up again it takes the free slot whose player was last
+ *   seen nearest to it (slots never seen go in order).
+ * - Bodies beyond the number of players are not players: they are in `extras` (e.g. for a faint drawing). An extra
+ *   stays an extra while it stays in view: a grown-up behind the children never takes the place of one who stepped
+ *   out for a moment.
+ */
+export declare class BodyTracker {
+	readonly players: number;
+	/** The last place of each slot's player; null if never seen (or forgotten after all were lost). */
+	private last;
+	/** Whether each slot's player was in the previous frame. */
+	private present;
+	private readonly maxJump;
+	private extraBodies;
+	private extraAnchors;
+	constructor(players: number, options?: BodyTrackerOptions);
+	/** The bodies of the last update that are not players (more bodies than players), left to right. */
+	get extras(): Body$1[];
+	/** Forgets everyone: the next update assigns left to right. */
+	reset(): void;
+	/** One frame's bodies, in any order → one entry per player slot (0-based; player id = slot + 1), null if not seen. */
+	update(bodies: readonly Body$1[]): (Body$1 | null)[];
+}
+
+export {};

package/dist/index.js

@@ -0,0 +1,691 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+import { P as P2 } from "@fabi-play/protocol";
+
+// src/distance.ts
+import { P } from "@fabi-play/protocol";
+var DISTANCE = {
+  /** The closest the eyes should be: this many diagonals (between THX's 1.2 and SMPTE's 1.6). */
+  eyeMinPerDiagonal: 1.5,
+  /** The farthest the screen stays readable: this many diagonals. */
+  readMaxPerDiagonal: 3,
+  /** The farthest the camera tracks reliably, metres (BlazePose's 2–4 m). */
+  trackingMaxM: 4,
+  /** The camera must see the whole body plus this much (feet and raised hands, a jump). */
+  cameraMargin: 1.15,
+  /** When the screen is too small for both (a tablet), the zone starts where the camera sees everyone and is this deep, metres. */
+  smallScreenDepthM: 0.5,
+  /** Typical heights of each age band, metres (WHO, median at the band's middle). */
+  heightM: { "3-5": 1.05, "6-8": 1.25, "9-12": 1.45 },
+  /** Field of view across the long side of the image when the phone can't say (the web phone), degrees. */
+  defaultFovLongDeg: 65,
+  /** Where the landmarks are, as fractions of stature from the floor (children). */
+  eyes: 0.91,
+  nose: 0.885,
+  ankles: 0.04,
+  /** Shoulders to hips (midpoints), as a fraction of stature. */
+  torso: 0.29,
+  /** Shoulder to shoulder, as a fraction of stature. */
+  shoulders: 0.22,
+  /**
+   * The feet are doubted (taken as out of the picture) when the torso puts the child nearer than this fraction of
+   * what the eyes-to-ankles span says: the two agree within a few per cent on a whole body.
+   */
+  feetDoubt: 0.75,
+  /** A landmark counts as seen from this visibility. */
+  visible: 0.5
+};
+var INCH_M = 0.0254;
+var rad = (deg2) => deg2 * Math.PI / 180;
+var deg = (r) => r * 180 / Math.PI;
+function imageFov(sensor, aspect) {
+  const tl = Math.tan(rad(sensor.long) / 2);
+  const ts = Math.tan(rad(sensor.short) / 2);
+  const sensorRatio = tl / ts;
+  const ratio = aspect >= 1 ? aspect : 1 / aspect;
+  const long = ratio >= sensorRatio ? tl : ts * ratio;
+  const short = ratio >= sensorRatio ? tl / ratio : ts;
+  const longDeg = deg(2 * Math.atan(long));
+  const shortDeg = deg(2 * Math.atan(short));
+  return aspect >= 1 ? { h: longDeg, v: shortDeg } : { h: shortDeg, v: longDeg };
+}
+function sensorFromLong(longDeg) {
+  return { long: longDeg, short: deg(2 * Math.atan(Math.tan(rad(longDeg) / 2) * 0.75)) };
+}
+var defaultFov = (aspect) => imageFov(sensorFromLong(DISTANCE.defaultFovLongDeg), aspect);
+var tallestHeight = (ranges) => Math.max(...(ranges.length ? ranges : ["9-12"]).map((r) => DISTANCE.heightM[r]));
+function zoneFor(o) {
+  const diagonal = o.inches * INCH_M;
+  const height = (o.heightM ?? DISTANCE.heightM["9-12"]) * DISTANCE.cameraMargin;
+  const cameraMin = height / (2 * Math.tan(rad(o.fovV) / 2));
+  const eyeMin = DISTANCE.eyeMinPerDiagonal * diagonal;
+  const readMax = DISTANCE.readMaxPerDiagonal * diagonal;
+  const min = Math.max(eyeMin, cameraMin);
+  const max = Math.min(readMax, DISTANCE.trackingMaxM);
+  const round = (n) => Math.round(n * 10) / 10;
+  if (max < min) return { min: round(cameraMin), max: round(cameraMin + DISTANCE.smallScreenDepthM), eyeMin, cameraMin, readMax, small: true };
+  return { min: round(min), max: round(max), eyeMin, cameraMin, readMax, small: false };
+}
+var point = (b, i) => ({ x: b[i * 3], y: b[i * 3 + 1], v: b[i * 3 + 2] });
+function estimateDistance(body, fov, ageRange) {
+  const H = DISTANCE.heightM[ageRange];
+  const seen2 = (p) => p.v >= DISTANCE.visible;
+  const perV = 2 * Math.tan(rad(fov.v) / 2);
+  const perH = 2 * Math.tan(rad(fov.h) / 2);
+  const nose = point(body, P.nose);
+  const le = point(body, 2);
+  const re = point(body, 5);
+  const la = point(body, P.leftAnkle);
+  const ra = point(body, P.rightAnkle);
+  const ls = point(body, P.leftShoulder);
+  const rs = point(body, P.rightShoulder);
+  const lh = point(body, P.leftHip);
+  const rh = point(body, P.rightHip);
+  const inImage = (p) => p.y < 0.995;
+  const feet = seen2(la) && seen2(ra) && inImage(la) && inImage(ra);
+  const eyes = seen2(le) && seen2(re) && le.y > 5e-3 && re.y > 5e-3;
+  const top = eyes ? { y: (le.y + re.y) / 2, at: DISTANCE.eyes } : seen2(nose) && nose.y > 5e-3 ? { y: nose.y, at: DISTANCE.nose } : null;
+  let torso = null;
+  if (seen2(ls) && seen2(rs) && seen2(lh) && seen2(rh)) {
+    const length = Math.hypot((ls.x + rs.x - lh.x - rh.x) / 2 * (perH / perV), (ls.y + rs.y - lh.y - rh.y) / 2);
+    if (length > 0.01) torso = DISTANCE.torso * H / (perV * length);
+  }
+  if (feet && top) {
+    const span = (la.y + ra.y) / 2 - top.y;
+    const body2 = span > 0.02 ? (top.at - DISTANCE.ankles) * H / (perV * span) : null;
+    if (body2 !== null && !(torso !== null && torso < body2 * DISTANCE.feetDoubt)) return { distance: body2, source: "body", partial: false };
+  }
+  if (torso !== null) return { distance: torso, source: "torso", partial: true };
+  if (seen2(ls) && seen2(rs)) {
+    const width = Math.abs(ls.x - rs.x);
+    if (width > 0.01) return { distance: DISTANCE.shoulders * H / (perH * width), source: "shoulders", partial: true };
+  }
+  return { distance: null, source: null, partial: true };
+}
+var DistanceTracker = class {
+  constructor(o = {}) {
+    __publicField(this, "samples", []);
+    __publicField(this, "placeNow", "unknown");
+    __publicField(this, "lastSeen", -Infinity);
+    __publicField(this, "partialNow", false);
+    __publicField(this, "windowMs");
+    __publicField(this, "margin");
+    __publicField(this, "forgetMs");
+    this.windowMs = o.windowMs ?? 500;
+    this.margin = o.margin ?? 0.1;
+    this.forgetMs = o.forgetMs ?? 700;
+  }
+  /** A frame: this child's estimate (null: not seen), against the zone. */
+  update(estimate, zone, now) {
+    if (estimate && estimate.distance !== null && Number.isFinite(estimate.distance)) {
+      this.samples.push({ t: now, d: estimate.distance });
+      this.lastSeen = now;
+      this.partialNow = estimate.partial;
+    }
+    while (this.samples.length && now - this.samples[0].t > this.windowMs) this.samples.shift();
+    if (now - this.lastSeen > this.forgetMs || !this.samples.length) {
+      this.placeNow = "unknown";
+      return { distance: null, place: "unknown", partial: false };
+    }
+    const d = median(this.samples.map((s) => s.d));
+    const m = this.margin;
+    const was = this.placeNow;
+    let place;
+    if (was === "near") place = d > zone.min + m ? d > zone.max + m ? "far" : "in" : "near";
+    else if (was === "far") place = d < zone.max - m ? d < zone.min - m ? "near" : "in" : "far";
+    else if (was === "in") place = d < zone.min - m ? "near" : d > zone.max + m ? "far" : "in";
+    else place = d < zone.min ? "near" : d > zone.max ? "far" : "in";
+    this.placeNow = place;
+    return { distance: d, place, partial: this.partialNow };
+  }
+  reset() {
+    this.samples.length = 0;
+    this.placeNow = "unknown";
+    this.lastSeen = -Infinity;
+    this.partialNow = false;
+  }
+};
+function median(values) {
+  const s = values.slice().sort((a, b) => a - b);
+  const mid2 = s.length >> 1;
+  return s.length % 2 ? s[mid2] : (s[mid2 - 1] + s[mid2]) / 2;
+}
+var TooCloseGuard = class {
+  constructor(o = {}) {
+    __publicField(this, "nearSince", []);
+    /** Since when each child near before is not measurable any more (see lostMs). */
+    __publicField(this, "lostSince", []);
+    __publicField(this, "clearSince", null);
+    __publicField(this, "stateNow", "ok");
+    __publicField(this, "pause");
+    __publicField(this, "enterMs");
+    __publicField(this, "resumeMs");
+    __publicField(this, "lostMs");
+    this.pause = o.pause ?? true;
+    this.enterMs = o.enterMs ?? 2e3;
+    this.resumeMs = o.resumeMs ?? 1e3;
+    this.lostMs = o.lostMs ?? 2500;
+  }
+  get state() {
+    return this.stateNow;
+  }
+  /** The grown-up's option changed: a pause in progress becomes a warning (off), or a warning a pause (on). */
+  setPause(pause) {
+    this.pause = pause;
+  }
+  update(places, now) {
+    const was = this.stateNow;
+    this.nearSince.length = this.lostSince.length = places.length;
+    places.forEach((p, i) => {
+      var _a;
+      const since = this.nearSince[i] ?? null;
+      if (p === "near") {
+        this.nearSince[i] = since ?? now;
+        this.lostSince[i] = null;
+      } else if (p === "unknown" && since !== null) {
+        const lost = (_a = this.lostSince)[i] ?? (_a[i] = now);
+        if (now - lost > this.lostMs) this.nearSince[i] = this.lostSince[i] = null;
+      } else this.nearSince[i] = this.lostSince[i] = null;
+    });
+    const near = places.flatMap((_, i) => this.nearSince[i] != null ? [i] : []);
+    const tooLong = near.filter((i) => now - this.nearSince[i] >= this.enterMs);
+    if (was === "paused") {
+      const clear = places.length > 0 && places.every((p) => p === "in" || p === "far");
+      if (!clear) this.clearSince = null;
+      else this.clearSince ?? (this.clearSince = now);
+      if (clear && now - this.clearSince >= this.resumeMs) {
+        this.stateNow = "ok";
+        this.clearSince = null;
+      } else if (!this.pause) this.stateNow = near.length ? "warn" : "ok";
+      const who = places.flatMap((p, i) => p === "in" || p === "far" ? [] : [i]);
+      return this.result(was, this.stateNow === "paused" ? who : near);
+    }
+    if (tooLong.length) this.stateNow = this.pause ? "paused" : "warn";
+    else if (was === "warn" && !near.length) this.stateNow = "ok";
+    this.clearSince = null;
+    return this.result(was, this.stateNow === "ok" ? [] : near);
+  }
+  /** Back to nothing (a new game, a grown-up's resume): the times start again. */
+  reset() {
+    this.nearSince = [];
+    this.lostSince = [];
+    this.clearSince = null;
+    this.stateNow = "ok";
+  }
+  result(was, who) {
+    return { state: this.stateNow, who, changed: was !== this.stateNow };
+  }
+};
+function zoneAdvice(reading, zone) {
+  if (reading.place === "unknown" || reading.distance === null) return "none";
+  if (reading.place === "near") return reading.distance < zone.min - 0.6 ? "two-steps-back" : "step-back";
+  if (reading.partial) return "step-back";
+  if (reading.place === "far") return "come-closer";
+  return "perfect";
+}
+var CAMERA_HEIGHT_M = 0.6;
+function bodyAtDistance(o) {
+  const H = o.heightM;
+  const d = Math.max(o.distance, 0.05);
+  const perV = 2 * Math.tan(rad(o.fov.v) / 2) * d;
+  const perH = 2 * Math.tan(rad(o.fov.h) / 2) * d;
+  const cx = o.x ?? 0.5;
+  const at = {
+    0: [0, DISTANCE.nose],
+    2: [-0.025, DISTANCE.eyes],
+    5: [0.025, DISTANCE.eyes],
+    7: [-0.055, 0.9],
+    8: [0.055, 0.9],
+    [P.leftShoulder]: [-DISTANCE.shoulders / 2, 0.8],
+    [P.rightShoulder]: [DISTANCE.shoulders / 2, 0.8],
+    [P.leftElbow]: [-0.13, 0.64],
+    [P.rightElbow]: [0.13, 0.64],
+    [P.leftWrist]: [-0.14, 0.48],
+    [P.rightWrist]: [0.14, 0.48],
+    [P.leftHip]: [-0.06, 0.51],
+    [P.rightHip]: [0.06, 0.51],
+    [P.leftKnee]: [-0.06, 0.28],
+    [P.rightKnee]: [0.06, 0.28],
+    [P.leftAnkle]: [-0.06, DISTANCE.ankles],
+    [P.rightAnkle]: [0.06, DISTANCE.ankles],
+    29: [-0.065, 0.02],
+    30: [0.065, 0.02],
+    31: [-0.06, 5e-3],
+    32: [0.06, 5e-3]
+  };
+  const out = [];
+  for (let i = 0; i < 33; i++) {
+    const [side, z] = at[i] ?? [0, DISTANCE.eyes];
+    const x = cx + side * H / perH;
+    const y = 0.5 - (z * H - CAMERA_HEIGHT_M) / perV;
+    const inside = x >= 0 && x <= 1 && y >= 0 && y <= 1;
+    out.push(Math.min(Math.max(x, 0), 1), Math.min(Math.max(y, 0), 1), inside ? 0.95 : 0);
+  }
+  return out;
+}
+function placeAtDistance(body, o) {
+  const ref = o.reference ?? body;
+  const y = (i) => ref[i * 3 + 1];
+  const top = (y(2) + y(5)) / 2;
+  const feet = (y(P.leftAnkle) + y(P.rightAnkle)) / 2;
+  const span = feet - top;
+  if (!(span > 0.02)) return body;
+  const perV = 2 * Math.tan(rad(o.fov.v) / 2) * Math.max(o.distance, 0.05);
+  const want = (DISTANCE.eyes - DISTANCE.ankles) * o.heightM / perV;
+  const k = want / span;
+  const anchorY = feet - (CAMERA_HEIGHT_M / o.heightM - DISTANCE.ankles) / (DISTANCE.eyes - DISTANCE.ankles) * span;
+  const anchorX = (ref[P.leftHip * 3] + ref[P.rightHip * 3]) / 2;
+  const out = body.slice();
+  for (let i = 0; i < body.length; i += 3) {
+    const x = anchorX + (body[i] - anchorX) * k;
+    const yy = 0.5 + (body[i + 1] - anchorY) * k;
+    const inside = x >= 0 && x <= 1 && yy >= 0 && yy <= 1;
+    out[i] = Math.min(Math.max(x, 0), 1);
+    out[i + 1] = Math.min(Math.max(yy, 0), 1);
+    if (!inside) out[i + 2] = 0;
+  }
+  return out;
+}
+
+// src/index.ts
+var landmark = (body, i) => ({ x: body[i * 3], y: body[i * 3 + 1], visibility: body[i * 3 + 2] });
+var VISIBLE = 0.5;
+var mid = (a, b) => ({ x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });
+var dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function skeleton(body) {
+  const l = (i) => landmark(body, i);
+  const s = {
+    nose: l(P2.nose),
+    leftShoulder: l(P2.leftShoulder),
+    rightShoulder: l(P2.rightShoulder),
+    leftElbow: l(P2.leftElbow),
+    rightElbow: l(P2.rightElbow),
+    leftWrist: l(P2.leftWrist),
+    rightWrist: l(P2.rightWrist),
+    leftHip: l(P2.leftHip),
+    rightHip: l(P2.rightHip),
+    leftAnkle: l(P2.leftAnkle),
+    rightAnkle: l(P2.rightAnkle)
+  };
+  const shoulders = mid(s.leftShoulder, s.rightShoulder);
+  const hips = mid(s.leftHip, s.rightHip);
+  return {
+    ...s,
+    shoulders,
+    hips,
+    ankles: mid(s.leftAnkle, s.rightAnkle),
+    torso: Math.max(dist(shoulders, hips), 0.01),
+    shoulderWidth: Math.max(dist(s.leftShoulder, s.rightShoulder), 0.01)
+  };
+}
+var seen = (...points) => points.every((p) => p.visibility >= VISIBLE);
+function shapeOf(body) {
+  return shapeIn(skeleton(body));
+}
+function shapeIn(s) {
+  if (!seen(s.leftWrist, s.rightWrist, s.leftShoulder, s.rightShoulder)) return null;
+  if (crossedIn(s)) return null;
+  const t = s.torso;
+  const upL = (s.leftShoulder.y - s.leftWrist.y) / t;
+  const upR = (s.rightShoulder.y - s.rightWrist.y) / t;
+  const spread = Math.abs(s.leftWrist.x - s.rightWrist.x) / s.shoulderWidth;
+  const legsApart = seen(s.leftAnkle, s.rightAnkle) && Math.abs(s.leftAnkle.x - s.rightAnkle.x) / s.shoulderWidth > 1.6;
+  if (upL > 0.6 && upR > 0.6) return spread > 2.2 ? "arms-v" : "arms-up";
+  if (Math.abs(upL) < 0.3 && Math.abs(upR) < 0.3 && spread > 3) return legsApart ? "star" : "arms-wide";
+  if (upL < -0.6 && upR < -0.6 && spread < 2) return "arms-down";
+  return null;
+}
+function armsCrossed(body) {
+  return crossedIn(skeleton(body));
+}
+function crossedIn(s) {
+  if (!seen(s.leftShoulder, s.rightShoulder, s.leftElbow, s.rightElbow, s.leftWrist, s.rightWrist)) return false;
+  const hipsSeen = seen(s.leftHip, s.rightHip);
+  const t = hipsSeen ? s.torso : s.shoulderWidth / CROSS.shoulderPerTorso;
+  if (s.shoulderWidth < CROSS.minShoulderWidth * t) return false;
+  const dir = Math.sign(s.rightShoulder.x - s.leftShoulder.x);
+  const m = s.shoulders.x;
+  const top = s.shoulders.y;
+  const bottom = hipsSeen ? s.hips.y : top + t;
+  const crossL = dir * (s.leftWrist.x - m) / t;
+  const crossR = dir * (m - s.rightWrist.x) / t;
+  const elbowL = dir * (m - s.leftElbow.x) / t;
+  const elbowR = dir * (s.rightElbow.x - m) / t;
+  const reach = 0.5 * s.shoulderWidth / t + CROSS.pastShoulder;
+  if (crossL < CROSS.past || crossR < CROSS.past || crossL > reach || crossR > reach) return false;
+  if (elbowL < CROSS.elbowOut || elbowR < CROSS.elbowOut) return false;
+  for (const w of [s.leftWrist, s.rightWrist]) if (w.y < top - CROSS.above * t || w.y > top + CROSS.below * t) return false;
+  for (const e of [s.leftElbow, s.rightElbow]) if (e.y < top - CROSS.elbowAbove * t || e.y > bottom + CROSS.elbowBelowHips * t) return false;
+  const rises = (w, e) => (e.y - w.y) / t >= CROSS.rise;
+  const clear = (w, otherElbow) => (otherElbow.y - w.y) / t >= CROSS.overElbow;
+  return rises(s.leftWrist, s.leftElbow) && rises(s.rightWrist, s.rightElbow) && clear(s.leftWrist, s.rightElbow) && clear(s.rightWrist, s.leftElbow);
+}
+var CROSS = {
+  /** Each wrist at least this far past the midline (between the shoulders)… */
+  past: 0.12,
+  /** …and no farther than the opposite shoulder plus this. */
+  pastShoulder: 0.1,
+  /** Each elbow at least this far from the midline, on its own side. */
+  elbowOut: 0.35,
+  /** Wrists between this far above the shoulder line… */
+  above: 0.35,
+  /** …and this far below it (mid-chest). */
+  below: 0.6,
+  /** Each wrist at least this far above its own elbow (the forearm rises)… */
+  rise: 0.2,
+  /** …and this far above the other arm's elbow. */
+  overElbow: 0.15,
+  /** Elbows no higher than this above the shoulder line (arms crossed over the head are not it)… */
+  elbowAbove: 0.1,
+  /** …and no lower than this below the hip line. */
+  elbowBelowHips: 0.3,
+  /** Shoulders at least this wide: facing the camera. */
+  minShoulderWidth: 0.3,
+  /** Shoulder width over torso, to estimate the torso when the hips are out of view. */
+  shoulderPerTorso: 0.8
+};
+var Hold = class {
+  constructor(ms = 1500, graceMs = 200) {
+    __publicField(this, "ms", ms);
+    __publicField(this, "graceMs", graceMs);
+    __publicField(this, "start", null);
+    __publicField(this, "lastActive", -Infinity);
+    __publicField(this, "progress", 0);
+    __publicField(this, "spent", false);
+  }
+  update(active, now) {
+    if (active) this.lastActive = now;
+    const released = !active && now - this.lastActive > this.graceMs;
+    if (released) {
+      this.start = null;
+      this.progress = 0;
+      this.spent = false;
+      return { progress: 0, fired: false };
+    }
+    if (this.spent) return { progress: 0, fired: false };
+    if (!active) return { progress: this.progress, fired: false };
+    this.start ?? (this.start = now);
+    this.progress = Math.min(Math.max((now - this.start) / this.ms, 0), 1);
+    if (this.progress < 1) return { progress: this.progress, fired: false };
+    this.spent = true;
+    this.progress = 0;
+    return { progress: 1, fired: true };
+  }
+  reset() {
+    this.start = null;
+    this.lastActive = -Infinity;
+    this.progress = 0;
+    this.spent = false;
+  }
+};
+var Dwell = class {
+  constructor(ms = 1500) {
+    __publicField(this, "ms", ms);
+    __publicField(this, "target", null);
+    __publicField(this, "start", 0);
+    __publicField(this, "spent", false);
+  }
+  update(target, now) {
+    if (target !== this.target) {
+      this.target = target;
+      this.start = now;
+      this.spent = false;
+    }
+    if (target === null || this.spent) return { target, progress: 0, fired: null };
+    const progress = Math.min(Math.max((now - this.start) / this.ms, 0), 1);
+    if (progress < 1) return { target, progress, fired: null };
+    this.spent = true;
+    return { target, progress: 1, fired: target };
+  }
+  reset() {
+    this.target = null;
+    this.start = 0;
+    this.spent = false;
+  }
+};
+var RAISED = 0.4;
+function menuPointer(body) {
+  const s = skeleton(body);
+  if (crossedIn(s)) return null;
+  const raised = (w, e, shoulder) => seen(w, e, shoulder) && (w.y < shoulder.y || e.y - w.y >= RAISED * s.torso);
+  const candidates = [
+    raised(s.leftWrist, s.leftElbow, s.leftShoulder) ? s.leftWrist : null,
+    raised(s.rightWrist, s.rightElbow, s.rightShoulder) ? s.rightWrist : null
+  ].filter((w) => w !== null);
+  if (!candidates.length) return null;
+  const wrist = candidates.reduce((a, b) => b.y < a.y ? b : a);
+  const p = spaceIn(s)(wrist);
+  return { x: clamp01(p.x), y: clamp01(p.y) };
+}
+var clamp01 = (n) => Math.min(Math.max(n, 0), 1);
+function placement(body, center = 0.5, radius = 0.12) {
+  if (!body) return "no-body";
+  const s = skeleton(body);
+  if (!seen(s.nose, s.leftHip, s.rightHip)) return "no-body";
+  const head = s.nose.y - s.torso * 0.6;
+  if (!seen(s.leftAnkle, s.rightAnkle) || s.ankles.y > 0.98 || head < 0.02) return "too-close";
+  const height = s.ankles.y - head;
+  if (height > 0.9) return "too-close";
+  if (height < 0.4) return "too-far";
+  if (s.hips.x < center - radius) return "go-right";
+  if (s.hips.x > center + radius) return "go-left";
+  return "ok";
+}
+function hands(body) {
+  return handsIn(skeleton(body));
+}
+function handsIn(s) {
+  const toScreen = spaceIn(s);
+  const at = (w) => {
+    if (w.visibility < VISIBLE) return null;
+    const p = toScreen(w);
+    return { x: clamp01(p.x), y: clamp01(p.y) };
+  };
+  return { left: at(s.leftWrist), right: at(s.rightWrist) };
+}
+function handSpace(body) {
+  return spaceIn(skeleton(body));
+}
+function spaceIn(s) {
+  const box = { x: s.shoulders.x - 1.6 * s.torso, y: s.shoulders.y - 1.6 * s.torso, w: 3.2 * s.torso, h: 3 * s.torso };
+  return (p) => ({ x: (p.x - box.x) / box.w, y: (p.y - box.y) / box.h });
+}
+var MotionTracker = class {
+  constructor(options = {}) {
+    __publicField(this, "hipBase", null);
+    __publicField(this, "ankleBase", null);
+    __publicField(this, "airborne", false);
+    __publicField(this, "crouched", false);
+    __publicField(this, "lane", 0);
+    __publicField(this, "clapOpen", false);
+    __publicField(this, "last", null);
+    __publicField(this, "energy", 0);
+    __publicField(this, "stillSince", null);
+    __publicField(this, "frozen", false);
+    __publicField(this, "smooth", { left: null, right: null });
+    /** The body update() read and its skeleton, so hands() on the same frame reuses it (once). */
+    __publicField(this, "read", null);
+    __publicField(this, "center");
+    this.center = options.center ?? 0.5;
+  }
+  /** The current lane: -1 left, 0 middle, 1 right. */
+  get currentLane() {
+    return this.lane;
+  }
+  /** One frame; t in ms. Returns the movements that started in it. */
+  update(body, t) {
+    const s = skeleton(body);
+    this.read = { body, s };
+    if (!seen(s.leftHip, s.rightHip, s.leftShoulder, s.rightShoulder)) return [];
+    const out = [];
+    const t0 = s.torso;
+    if (this.hipBase === null) this.hipBase = s.hips.y;
+    if (this.ankleBase === null && seen(s.leftAnkle, s.rightAnkle)) this.ankleBase = s.ankles.y;
+    const rise = (this.hipBase - s.hips.y) / t0;
+    const feetUp = this.ankleBase !== null && seen(s.leftAnkle, s.rightAnkle) ? (this.ankleBase - s.ankles.y) / t0 : rise;
+    if (!this.airborne && rise > 0.22 && feetUp > 0.12) {
+      this.airborne = true;
+      out.push("jump");
+    } else if (this.airborne && rise < 0.08) {
+      this.airborne = false;
+      out.push("land");
+    }
+    if (!this.crouched && !this.airborne && rise < -0.3) {
+      this.crouched = true;
+      out.push("squat");
+    } else if (this.crouched && rise > -0.12) {
+      this.crouched = false;
+      out.push("stand");
+    }
+    if (!this.airborne && !this.crouched) {
+      this.hipBase += (s.hips.y - this.hipBase) * 0.05;
+      if (this.ankleBase !== null && seen(s.leftAnkle, s.rightAnkle)) this.ankleBase += (s.ankles.y - this.ankleBase) * 0.05;
+    }
+    const side = (s.hips.x - this.center) / t0;
+    const lane = this.lane === 0 ? side < -0.7 ? -1 : side > 0.7 ? 1 : 0 : Math.abs(side) < 0.35 ? 0 : this.lane;
+    if (lane !== this.lane) {
+      this.lane = lane;
+      out.push(lane === -1 ? "lane-left" : lane === 1 ? "lane-right" : "lane-center");
+    }
+    if (seen(s.leftWrist, s.rightWrist)) {
+      const gap = dist(s.leftWrist, s.rightWrist) / s.shoulderWidth;
+      if (gap > 1) this.clapOpen = true;
+      else if (gap < 0.35 && this.clapOpen) {
+        this.clapOpen = false;
+        out.push("clap");
+      }
+    }
+    const points = [s.nose, s.leftWrist, s.rightWrist, s.hips, s.leftAnkle, s.rightAnkle];
+    if (this.last && t > this.last.t) {
+      const moved = points.reduce((sum, p, i) => sum + dist(p, this.last.points[i]), 0) / points.length / t0;
+      const speed = moved / ((t - this.last.t) / 1e3);
+      this.energy += (speed - this.energy) * 0.3;
+      if (this.energy < 0.25) {
+        this.stillSince ?? (this.stillSince = t);
+        if (!this.frozen && t - this.stillSince >= 600) {
+          this.frozen = true;
+          out.push("freeze");
+        }
+      } else {
+        this.stillSince = null;
+        if (this.frozen && this.energy > 0.6) {
+          this.frozen = false;
+          out.push("move");
+        }
+      }
+    }
+    this.last = { t, points };
+    return out;
+  }
+  /** The hands as pointers, smoothed so they don't tremble. */
+  hands(body) {
+    const s = this.read?.body === body ? this.read.s : skeleton(body);
+    this.read = null;
+    const raw = handsIn(s);
+    const ease = (prev, next) => next && prev ? { x: prev.x + (next.x - prev.x) * 0.5, y: prev.y + (next.y - prev.y) * 0.5 } : next;
+    this.smooth = { left: ease(this.smooth.left, raw.left), right: ease(this.smooth.right, raw.right) };
+    return this.smooth;
+  }
+};
+var anchor = (body) => {
+  const s = skeleton(body);
+  return { x: (s.shoulders.x + s.hips.x) / 2, y: (s.shoulders.y + s.hips.y) / 2, torso: s.torso };
+};
+var cost = (was, now) => dist(was, now) / was.torso + Math.abs(Math.log(now.torso / was.torso));
+var BodyTracker = class {
+  constructor(players, options = {}) {
+    __publicField(this, "players", players);
+    /** The last place of each slot's player; null if never seen (or forgotten after all were lost). */
+    __publicField(this, "last");
+    /** Whether each slot's player was in the previous frame. */
+    __publicField(this, "present");
+    __publicField(this, "maxJump");
+    __publicField(this, "extraBodies", []);
+    __publicField(this, "extraAnchors", []);
+    if (!Number.isInteger(players) || players < 0) throw new RangeError("players: a whole number \u2265 0");
+    this.maxJump = options.maxJump ?? 1.5;
+    this.last = Array.from({ length: players }, () => null);
+    this.present = Array.from({ length: players }, () => false);
+  }
+  /** The bodies of the last update that are not players (more bodies than players), left to right. */
+  get extras() {
+    return this.extraBodies;
+  }
+  /** Forgets everyone: the next update assigns left to right. */
+  reset() {
+    this.last.fill(null);
+    this.present.fill(false);
+    this.extraBodies = [];
+    this.extraAnchors = [];
+  }
+  /** One frame's bodies, in any order → one entry per player slot (0-based; player id = slot + 1), null if not seen. */
+  update(bodies) {
+    const out = Array.from({ length: this.players }, () => null);
+    const anchors = bodies.map(anchor);
+    const free = new Set(anchors.keys());
+    const slots = out.map((_, s) => s);
+    const take = (slot, b) => {
+      out[slot] = bodies[b];
+      this.last[slot] = anchors[b];
+      free.delete(b);
+    };
+    if (!this.present.some(Boolean)) this.last.fill(null);
+    nearest(slots.filter((s) => this.present[s]).map((s) => [s, this.last[s]]), free, anchors, this.maxJump, take);
+    const stayExtra = /* @__PURE__ */ new Set();
+    nearest([...this.extraAnchors.entries()], free, anchors, this.maxJump, (_, b) => stayExtra.add(b));
+    stayExtra.forEach((b) => free.delete(b));
+    nearest(slots.filter((s) => !out[s] && this.last[s]).map((s) => [s, this.last[s]]), free, anchors, Infinity, take);
+    const leftToRight = (set) => [...set].sort((a, b) => anchors[a].x - anchors[b].x);
+    const rest = leftToRight(free);
+    for (const s of slots) if (!out[s] && !this.last[s] && rest.length) take(s, rest.shift());
+    slots.forEach((s) => this.present[s] = out[s] !== null);
+    const extras = leftToRight(/* @__PURE__ */ new Set([...free, ...stayExtra]));
+    this.extraAnchors = extras.map((b) => anchors[b]);
+    this.extraBodies = extras.map((b) => bodies[b]);
+    return out;
+  }
+};
+function nearest(from, free, anchors, limit, pair) {
+  const pairs = [];
+  for (const [key, was] of from) for (const b of free) pairs.push({ key, b, c: cost(was, anchors[b]) });
+  pairs.sort((p, q) => p.c - q.c);
+  const keys = /* @__PURE__ */ new Set();
+  const used = /* @__PURE__ */ new Set();
+  for (const p of pairs) {
+    if (p.c > limit || keys.has(p.key) || used.has(p.b)) continue;
+    keys.add(p.key);
+    used.add(p.b);
+    pair(p.key, p.b);
+  }
+}
+export {
+  BodyTracker,
+  CROSS,
+  DISTANCE,
+  DistanceTracker,
+  Dwell,
+  Hold,
+  MotionTracker,
+  RAISED,
+  TooCloseGuard,
+  armsCrossed,
+  bodyAtDistance,
+  defaultFov,
+  estimateDistance,
+  handSpace,
+  hands,
+  imageFov,
+  landmark,
+  menuPointer,
+  placeAtDistance,
+  placement,
+  sensorFromLong,
+  shapeOf,
+  skeleton,
+  tallestHeight,
+  zoneAdvice,
+  zoneFor
+};

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@fabi-play/motion",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Body movements from pose landmarks: jumps, squats, shapes, lanes, freezing, hands as pointers.",
+  "keywords": [
+    "fabi-play",
+    "motion",
+    "pose",
+    "gestures",
+    "games"
+  ],
+  "homepage": "https://docs.fabiplay.app",
+  "bugs": "https://github.com/fabiplay/fabiplay-kit/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fabiplay/fabiplay-kit.git",
+    "directory": "packages/motion"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Fabi Play (https://fabiplay.app)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@fabi-play/protocol": "^0.1.0"
+  },
+  "devDependencies": {
+    "dts-bundle-generator": "9.5.1",
+    "esbuild": "0.28.2",
+    "tsx": "4.23.15",
+    "typescript": "5.7.3"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts",
+    "build": "node ../../scripts/build-lib.mjs"
+  },
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  }
 }