@fabi-play/sdk 0.2.0 → 0.3.0

package/README.md

@@ -80,6 +80,85 @@ of the game, or a move shown with the children's own avatars, which they can als
 - **An invalid intro** is reported by the check (the Studio, `parseManifest`, the JSON Schema) and skipped by the
   TV: it never blocks the game.
 
+## Where the children are: the view and framing
+
+`play.view` is where the camera image lies on your page, so each child's avatar and hands are where the child stands.
+Draw anything that belongs to a child at `play.toScreen(point)` (a wrist, the head, the avatar's box), never at your
+own mapping of player space.
+
+The view is not fixed. By default the screen frames the children: when they stand far from the camera it zooms in on
+them, up to 1.8×, so every child's avatar is about the same size and reaches the same things, near or far. It decides
+the zoom at calibration and changes it only in breaks (pause, level, turn), never during play; the image may then
+reach past every edge of the page. Listen for it:
+
+```js
+play.onBackdrop((backdrop, view) => layoutAround(view))
+```
+
+A game drawn on exact spots of the live video can keep the whole image with `"framing": "fixed"` in `fabi-play.json`.
+
+## Playing with the TV remote
+
+On TVs (Samsung, LG, Android TV, Fire TV) Fabi Play can be played without a phone: with the TV remote. A game
+opts in with `inputs` in `fabi-play.json`:
+
+```json
+"inputs": ["body", "remote"]
+```
+
+- **`inputs`** is optional; absent means `["body"]`. It always includes `"body"` (Fabi Play is a movement
+  platform), lists each input once, and knows only `body` and `remote`: anything else is an error in the check
+  (the Studio, `parseManifest`, the JSON Schema).
+- **With one child, most games need no code.** The screen turns the remote's keys into the gestures the body makes, and animates a
+  puppet body in the frames (as the simulator does), so `gesture` events, `drawAvatar` and the keyboard adapter
+  (`data-keys`, `FabiPlay.keys()`) work as with a camera:
+
+  | Key | Gesture |
+  | --- | --- |
+  | ↑ or OK | `jump` (then `land`) |
+  | ↓ held | `squat`, then `stand` on release |
+  | ← / → | `lane-left` / `lane-right` (stepping back to the middle is `lane-center`, as with the body) |
+  | OK twice quickly | `clap` |
+  | Back | Fabi Play's pause (a `pause` message), never the game's |
+
+  Nothing else is made: no hands aiming, no shapes, no freeze. The game never gets the keys themselves.
+- **The Magic Remote (LG) points too.** It reaches the game as ordinary pointer and mouse events: hover, and a
+  click with OK. `play.pointer` is `true` when the remote points (only with `"remote"`). A game that lists
+  `"remote"` must work with the arrow keys alone and, where it has things to pick (bubbles, answers, buttons), let a
+  pointer click them as well: pointer events, large hit areas, a hover highlight. Fabi Play's own menus, pickers
+  and turn screen are clickable too.
+- **One remote is one child; several children take turns, a round each, if the game follows the contract.**
+  Turns are not free: the game must follow the steps below, and say so in `fabi-play.json` with
+  `"turns": true` (only next to `"remote"` in `inputs`): `"inputs": ["body", "remote"], "turns": true`. A game
+  with `"turns": true` follows the turn contract. Only then does the screen offer several children with the
+  remote; without it, remote mode is one child only.
+
+  The game sees one child at a time. `play.players` is the child playing now (exactly one id, a frozen array: read
+  it again after a turn), and `play.turns` is every child who plays, in order (`[1, 2, 3]`; one child, or the body:
+  the same as `play.players`). The contract:
+  1. Play a round (a race, a level) with the child in `play.players`.
+  2. When that child's round ends, whatever happened in it (a crash or a fall ends a round too), and turns remain,
+     call `play.break('turn')`. The screen always answers `break-start` (its turn screen is the break, and may
+     show an ad), then a `turn` message (`play.on('turn', ({ players }) => …)`, or `FabiPlay.on('turn', …)`),
+     after which `play.players` is the next child, then `break-done`. Start that child's round.
+  3. After the last child's round, call `play.end()` with every child's scores:
+     `play.end([{ player: 1, … }, { player: 2, … }])`.
+
+  Only `break('turn')` swaps children: `break('level')` and `break('gameover')` never do, so a round never changes
+  hands midway. The SDK takes a `turn` only inside a `'turn'` break, and only to the next child in `play.turns`; it
+  drops any other. Player ids keep their meaning (slots, avatars): keep each child's score by id. At a turn the next
+  child's puppet starts recentred, in the middle lane, with no lane gesture (the keyboard adapter resets its lane
+  too). With the simple API, `score(n)`
+  without a player goes to the child playing now, and `end(n)` gives the child playing now `n` and each child
+  before them their last `score()` (or 0). A body session never gets a `turn`: its players stay for the whole
+  game.
+- **Adapt with `play.input`** (`'body'`, the default and what older screens mean, or `'remote'`; also in the
+  `start` event with `pointer`, and live as `FabiPlay.input`, `FabiPlay.hasPointer`, `FabiPlay.players`,
+  `FabiPlay.turns`): slow the game down a little, show a selection the arrows move (and a pointer
+  clicks) instead of a hand cursor, drop what the remote can't do.
+- **Games aimed with the hands** (`movements: ["hands"]`, the `pointer()` adapter) should not list `"remote"`
+  unless they offer a remote-friendly selection: a child with a remote has no hand cursor.
+
 Docs: https://docs.fabiplay.app.
 
 ## License

package/dist/avatars.js

@@ -6,7 +6,7 @@ import {
   drawShapes,
   frameOf,
   iconShapes
-} from "./chunks/chunk-57WXWAXG.js";
+} from "./chunks/chunk-GFNOIOSX.js";
 export {
   BAND_BODY,
   DEFAULT_AVATAR,

package/dist/chunks/{chunk-57WXWAXG.js → chunk-GFNOIOSX.js}

@@ -57,6 +57,14 @@ function parseGameStats(v) {
   if (DEVICE_TIERS.includes(v.tier)) out.tier = v.tier;
   return out;
 }
+var isPlayerId = (id) => Number.isInteger(id) && id >= 1 && id <= MAX_PLAYERS;
+function parseTurnPlayers(v) {
+  return Array.isArray(v) && v.length === 1 && isPlayerId(v[0]) ? [v[0]] : void 0;
+}
+function parseTurnOrder(v) {
+  if (!Array.isArray(v) || v.length < 1 || v.length > MAX_PLAYERS || !v.every(isPlayerId) || new Set(v).size !== v.length) return void 0;
+  return [...v];
+}
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isNumber = (v) => typeof v === "number" && Number.isFinite(v);
 var POSE_HEADER = 12;
@@ -2004,9 +2012,11 @@ function smoothBody(prev, next, amount = 0.5) {
     const wasSeen = pv >= 0.5;
     const isSeen = nv >= 0.5;
     if (wasSeen && nv >= 0.3) out[i + 2] = Math.max(nv, 0.5);
-    if (wasSeen && isSeen && Math.hypot(next[i] - prev[i], next[i + 1] - prev[i + 1]) < 0.15) {
-      out[i] = prev[i] + (next[i] - prev[i]) * amount;
-      out[i + 1] = prev[i + 1] + (next[i + 1] - prev[i + 1]) * amount;
+    const step = Math.hypot(next[i] - prev[i], next[i + 1] - prev[i + 1]);
+    if (wasSeen && isSeen && step < 0.15) {
+      const k = amount * Math.min(1, STILL_SHARE + (1 - STILL_SHARE) * step / STILL_FULL);
+      out[i] = prev[i] + (next[i] - prev[i]) * k;
+      out[i + 1] = prev[i + 1] + (next[i + 1] - prev[i + 1]) * k;
     } else if (wasSeen && !isSeen && out[i + 2] >= 0.5) {
       out[i] = prev[i];
       out[i + 1] = prev[i + 1];
@@ -2015,6 +2025,8 @@ function smoothBody(prev, next, amount = 0.5) {
   smoothFace(prev, next, out, amount * FACE_SMOOTHING);
   return out;
 }
+var STILL_SHARE = 0.1;
+var STILL_FULL = 0.03;
 var FACE_SMOOTHING = 0.35;
 var FACE_POINTS = 11;
 function smoothFace(prev, next, out, amount) {
@@ -2098,6 +2110,8 @@ export {
   toScreen,
   parseDeviceHint,
   parseGameStats,
+  parseTurnPlayers,
+  parseTurnOrder,
   drawShapes,
   BAND_BODY,
   frameOf,

package/dist/fabi-play.d.ts

@@ -7,8 +7,8 @@
 
 /** The Fabi Play SDK's types, for script-tag games: FabiPlay.PlayerFrame, FabiPlay.Point, FabiPlay.Gesture, … */
 declare namespace FabiPlay {
-	/** Anything with Play's on(): a Play, or a stand-in in tests. */
-	export type On = Pick<Play, "on">;
+	/** Anything with Play's on() (and, from a Play, who plays and how): a Play, or a stand-in in tests. */
+	export type On = Pick<Play, "on"> & Partial<Pick<Play, "input" | "players">>;
 	/** What the child does, as the keyboard adapter names it. */
 	export type Action = "jump" | "squat" | "left" | "right" | "clap" | "arms-up";
 	/** Action → key code (KeyboardEvent.code: Space, Enter, ArrowUp, KeyW, Digit1…). */
@@ -29,7 +29,11 @@ declare namespace FabiPlay {
 	}
 	/** Options of keyboard(). */
 	export interface KeyboardOptions {
-		/** Whose movements (default 1); another player can get other keys (e.g. WASD). */
+		/**
+		 * Whose movements (default 1); another player can get other keys (e.g. WASD). Not given and played with the
+		 * remote: the child playing now, following the turns (at a turn the lane is the middle one again, as the screen
+		 * recentres the puppet).
+		 */
 		player?: number;
 		/** Where the keys go: by default the page (domKeys()). */
 		target?: KeyTarget;
@@ -82,10 +86,15 @@ declare namespace FabiPlay {
 	/**
 	 * Why the game stops, when it asks for a break:
 	 * - level: a level is over (the best moment);
-	 * - gameover: the game is over and a new one may start.
-	 * Never at the game's own pause menu: a child who stops for a moment must not get an ad for it.
+	 * - gameover: the game is over and a new one may start;
+	 * - turn: with input 'remote' and turns remaining, the child playing now finished their round (whatever happened in
+	 *   it: a crash or a fall ends a round too). The screen always answers with break-start (its turn screen is the
+	 *   break, and may host an ad), then turn (the next child), then break-done. Hosts before turns answer it as an
+	 *   unknown reason (break-done at once), but they never send turns either.
+	 * Only 'turn' ever swaps players; 'level' and 'gameover' never do. Never at the game's own pause menu: a child who
+	 * stops for a moment must not get an ad for it.
 	 */
-	export type BreakReason = "level" | "gameover";
+	export type BreakReason = "level" | "gameover" | "turn";
 	/**
 	 * The movements the host recognises, per player:
 	 * - `jump`, then `land` when the feet are back on the ground;
@@ -140,7 +149,9 @@ declare namespace FabiPlay {
 	 * image is cropped to fill the screen), with any backdrop, so avatars and hands are where the children stand (a
 	 * "virtual mirror"). The screen decides it: with 'video', where the video is drawn (cover or contain); with 'none',
 	 * the whole image contained at 92% of the viewport's height, bottom-aligned. Games don't compute it: they just use
-	 * it. Body points are in player space (0–1 of the camera image, already mirrored like the video), so a point p is on
+	 * it. It is not fixed: with automatic framing (the default, see GameManifest.framing) the screen zooms in on children
+	 * standing far away, up to 1.8×, so the image may reach past every edge; it changes only at calibration and in breaks
+	 * (pause, level, turn), never during play, and arrives in a backdrop message. Body points are in player space (0–1 of the camera image, already mirrored like the video), so a point p is on
 	 * screen at (x + p.x·w, y + p.y·h): see toScreen.
 	 */
 	export interface BackdropView {
@@ -183,6 +194,22 @@ declare namespace FabiPlay {
 	/** view: where the camera image is, with any backdrop (see BackdropView); absent if the screen doesn't know. */
 	/** stats: a debug host (the simulator) asks the game to say how often it draws (stats messages); absent on the TV. */
 	/** device: what the screen knows about the device (a starting tier, the display's rate); absent if it knows nothing. */
+	/**
+	 * input: how this session is played (see GameInput); absent = 'body'. Only games whose manifest lists 'remote' ever
+	 * get 'remote'. With 'remote', players is exactly one id: the child playing now (see turn).
+	 */
+	/**
+	 * turns: only with input 'remote', and only to games whose manifest says "turns": true: every child who
+	 * will play this game, one id each, in turn order, players[0] first (see parseTurnOrder); absent = players (one
+	 * child, no turns). A round per child: at the end of each child's round, while turns remain, the game calls
+	 * break('turn'); the screen answers break-start, turn (the next child), break-done. After the last child's round
+	 * the game calls end() with every child's scores. An order that is not valid, or doesn't start with players[0],
+	 * makes the session one child only.
+	 */
+	/**
+	 * pointer: only with input 'remote', true when the TV's remote also points (LG's Magic Remote): it reaches the game
+	 * as ordinary pointer and mouse events (hover, click with OK). Absent = false.
+	 */
 	{
 		type: "init";
 		v: number;
@@ -195,8 +222,11 @@ declare namespace FabiPlay {
 		view?: BackdropView;
 		stats?: boolean;
 		device?: DeviceHint;
+		input?: GameInput;
+		turns?: number[];
+		pointer?: boolean;
 	}
-	/** The backdrop or the view changed mid-game (video switched on or off, the camera image's fit changed). */
+	/** The backdrop or the view changed mid-game (video switched on or off, the camera image's fit or framing changed). */
 	 | {
 		type: "backdrop";
 		backdrop: Backdrop;
@@ -235,6 +265,19 @@ declare namespace FabiPlay {
 	 | {
 		type: "break-done";
 		shown: boolean;
+	}
+	/**
+	 * Turns (input 'remote' only): from now on this child plays, in place of the one before. One remote is one child,
+	 * so with several children the screen plays one at a time: the same game goes on with the next child in init's
+	 * turns (players [2] after [1], …), exactly one id. Sent only inside the break of a break('turn') the game asked
+	 * for (after break-start, before break-done); never at other breaks, so a round never changes hands midway. The
+	 * new child's puppet starts recentred, in the middle lane (lane 0), with no lane gesture. Ids keep their meaning
+	 * (slots, avatars): keep each player's score by id across turns, and end with the scores of every child who
+	 * played. Never sent with input 'body', where init's players stay for the whole game.
+	 */
+	 | {
+		type: "turn";
+		players: number[];
 	};
 	/** Why a game is paused (see HostMessage pause). */
 	export type PauseReason = "user" | "distance";
@@ -330,7 +373,39 @@ declare namespace FabiPlay {
 		backdrop?: GameBackdrop[];
 		/** Optional: Fabi explains the game on the TV before calibration (see GameIntro). Absent: straight to calibration. */
 		intro?: GameIntro;
+		/** Optional: how it can be played; absent = ['body']. Must include 'body' (Fabi Play is a movement platform); add 'remote' to be offered without a phone. */
+		inputs?: GameInput[];
+		/**
+		 * Optional, only with 'remote' in inputs: true when the game follows the turns contract, so the screen may let
+		 * several children play with the remote, a round each (init.turns): play a round with the child in players; when
+		 * it ends (a crash too) and turns remain, ask break('turn') (the screen answers break-start, turn, break-done);
+		 * after the last round, end with every child's scores. Absent or false: remote mode is one child only.
+		 */
+		turns?: boolean;
+		/**
+		 * Optional: 'auto' (the default) lets the screen frame the children: when they stand far from the camera it zooms
+		 * in on them (up to 1.8×), so every child's avatar is about the same size and reaches the same things, near or
+		 * far; the view changes only at calibration and in breaks. 'fixed' keeps the whole camera image, as before (for
+		 * a game drawn on exact spots of the live video).
+		 */
+		framing?: GameFraming;
 	}
+	/** How the screen frames the camera image for a game: see GameManifest.framing. */
+	export type GameFraming = "auto" | "fixed";
+	/**
+	 * How a game can be played: with the body (camera on the phone), or with the TV remote (keys become gestures).
+	 *
+	 * 'remote' is for TV apps without a phone (Samsung, LG, Android TV, Fire TV): one remote is one child, and with
+	 * several children the screen runs turns, only for games whose manifest says "turns": true (see GameManifest.turns,
+	 * BreakReason turn, HostMessage turn). The screen turns keys into the gestures the body makes (↑ or OK jump;
+	 * ↓ held squat, stand on release; ← → lanes; OK twice quickly clap; Back is the platform's pause, never the game's)
+	 * and animates a puppet body in the frames, so with one child most games need no code. On LG the Magic
+	 * Remote also points: it reaches the game as ordinary pointer and mouse events (init.pointer says when). A game that
+	 * lists 'remote' must play with those keys alone and, where it has things to pick (bubbles, answers, buttons), let a
+	 * pointer click them too (pointer events, large hit areas, a hover highlight). Games aimed with the hands should not
+	 * list it unless they offer a selection the keys can drive.
+	 */
+	export type GameInput = "body" | "remote";
 	/** The backdrops a game may declare in its manifest (its own background is always supported). */
 	export type GameBackdrop = Exclude<Backdrop, "none">;
 	/** The moves an intro step can show; the platform draws them with each child's avatar. Same names the SDK detects. */
@@ -394,12 +469,12 @@ declare namespace FabiPlay {
 	export type DrawAvatar = (ctx: CanvasRenderingContext2D, who: PlayerFrame | Body, player?: number | string, box?: AvatarBox | null, options?: DrawAvatarOptions) => Body | null;
 	/** A frame's body smoothed (and interpolated) for its player, or a player id's last one; null if none. */
 	export type SmoothedBody = (who: PlayerFrame | number, options?: Pick<DrawAvatarOptions, "smooth" | "interpolate">) => Body | null;
-	/** What the 'start' event says: who plays and how. */
+	/** What the 'start' event says: who plays and how, as it was at the start (late listeners get the same; see Easy for now). */
 	export interface StartInfo {
 		/** The players' age range: simpler rules for 3-5, scores and challenges for 9-12. */
 		ageRange: AgeRange;
-		/** The ids of the players (1, 2, …). */
-		players: number[];
+		/** The ids of the players (1, 2, …) at the start, frozen; with input 'remote', the first child's turn (see the turn event). */
+		players: readonly number[];
 		/** The language to show text in. */
 		locale: Locale;
 		/** 'tv': on a TV, children standing back; 'solo': a tablet in front of one child. */
@@ -410,6 +485,12 @@ declare namespace FabiPlay {
 		view: BackdropView | null;
 		/** What the screen knows about the device (a starting tier, the display's rate), or null: see Play.device. */
 		device: DeviceHint | null;
+		/** Every child in turn order, frozen (with input 'remote', one round each; see Play.turns); otherwise players. */
+		turns: readonly number[];
+		/** 'body' (the default) or 'remote': played with the TV remote, keys turned into gestures (see Play.input). */
+		input: GameInput;
+		/** With input 'remote', whether the remote also points (LG's Magic Remote; see Play.pointer). */
+		pointer: boolean;
 	}
 	/**
 	 * The events of FabiPlay.on, by name, with what each listener gets. Every gesture (jump, land, squat, stand, clap,
@@ -461,6 +542,13 @@ declare namespace FabiPlay {
 			backdrop: Backdrop;
 			view: BackdropView | null;
 		};
+		/**
+		 * Remote mode only, inside the break of break('turn'): the next child's turn; players (one id) is who plays from
+		 * now on. Keep each player's score by id.
+		 */
+		turn: {
+			players: number[];
+		};
 	};
 	/** An event name of FabiPlay.on. */
 	export type EasyEvent = keyof EasyEvents;
@@ -477,7 +565,7 @@ declare namespace FabiPlay {
 	export interface Easy {
 		/**
 		 * Listens to an event: a gesture by its name ('jump', 'clap', 'lane-left', …), 'start', 'hands', 'shape',
-		 * 'players', 'pause', 'resume', 'break-start', 'break-end', 'backdrop' (see EasyEvents). Returns a function that
+		 * 'players', 'pause', 'resume', 'break-start', 'break-end', 'backdrop', 'turn' (see EasyEvents). Returns a function that
 		 * stops listening.
 		 *
 		 * @example
@@ -486,11 +574,14 @@ declare namespace FabiPlay {
 		on<K extends EasyEvent>(event: K, listener: (data: EasyEvents[K]) => void): () => void;
 		/** Say the game is loaded; done for you on page load unless the script tag says data-ready="manual". */
 		ready(): void;
-		/** The score so far, for the screen to show; player 1 unless said. */
+		/** The score so far, for the screen to show; player 1 unless said (with input 'remote', the child playing now). */
 		score(score: number, player?: number): void;
 		/** The game stopped by itself ('level' or 'gameover', never its pause menu): Fabi Play may show an ad. Resolves when it can go on. */
 		break(reason?: BreakReason): Promise<boolean>;
-		/** The end: a score, or one per player. Stars from 0 to 3, 2 if not given. */
+		/**
+		 * The end: a score (player 1's; with input 'remote', the child playing now's, and for each child who played
+		 * before them in turns their last score() or 0), or one per player. Stars from 0 to 3, 2 if not given.
+		 */
 		end(score: number | {
 			player: number;
 			score: number;
@@ -509,6 +600,14 @@ declare namespace FabiPlay {
 		 * clicks by staying still on a spot. The script tag's data-pointer does the same.
 		 */
 		pointer(options?: Omit<PointerOptions, "target">): void;
+		/** The players playing now (frozen; see Play.players); empty before start. */
+		readonly players: readonly number[];
+		/** Every child in turn order (frozen; see Play.turns); empty before start. */
+		readonly turns: readonly number[];
+		/** How this session is played (see Play.input); 'body' before start. */
+		readonly input: GameInput;
+		/** With input 'remote', whether the remote also points (Play.pointer; pointer() is the hand adapter); false before start. */
+		readonly hasPointer: boolean;
 		/** Where the camera image is, with any backdrop; null if the host didn't say, and before start. */
 		readonly view: BackdropView | null;
 		/** What the screen knows about the device (see Play.device); null if it said nothing, and before start. */
@@ -568,6 +667,14 @@ declare namespace FabiPlay {
 		backdrop: Extract<HostMessage, {
 			type: "backdrop";
 		}>;
+		/**
+		 * Remote mode only (input 'remote'), inside the break of a break('turn'): the next child's turn, the same game goes
+		 * on with this one player (see Play.players). Keep each player's score by id. The SDK passes on only a turn to the
+		 * next child in Play.turns, while a 'turn' break is under way; it drops any other.
+		 */
+		turn: Extract<HostMessage, {
+			type: "turn";
+		}>;
 	};
 	/**
 	 * The game's side of Fabi Play, from connect(): who plays, their movements, and how the game tells it is ready,
@@ -583,8 +690,39 @@ declare namespace FabiPlay {
 		readonly locale: Locale;
 		/** 'tv': on a TV or Chromecast, children standing back; 'solo': a tablet in front of one child. */
 		readonly mode: "tv" | "solo";
-		/** The ids of the players in this game (1, 2, …), as frames and gestures name them. */
-		readonly players: number[];
+		/**
+		 * The ids of the players playing now (1, 2, …), as frames and gestures name them; a frozen array, read it again
+		 * after a turn. With input 'body' the same for the whole game. With input 'remote' exactly one child, and it
+		 * changes only inside the break of a break('turn') (the 'turn' event, between break-start and break-done). Keep
+		 * each player's score by id across turns, and end with the scores of everyone who played.
+		 */
+		readonly players: readonly number[];
+		/**
+		 * Every child who plays this game, in turn order (frozen): with input 'remote' and several children, one round
+		 * each, players being the one playing now (turns[0] at the start). Only for games whose manifest says
+		 * "turns": true (with "remote" in inputs); otherwise remote mode is one child. The contract:
+		 * 1. play a round with the child in players;
+		 * 2. at the end of it (whatever happened: a crash ends a round too), if turns remain, call break('turn'): the
+		 *    screen always answers break-start (its turn screen), 'turn' (the next child), then break-done;
+		 * 3. after the last child's round, call end() with every child's scores.
+		 * 'level' and 'gameover' breaks never swap players. With 'body', one child, or hosts that don't say: players.
+		 */
+		readonly turns: readonly number[];
+		/**
+		 * How this session is played: 'body' (the camera on the phone; the default, and what older hosts mean) or
+		 * 'remote' (a TV without a phone, only for games whose manifest lists it in inputs): the screen turns the remote's
+		 * keys into the same gestures (↑ or OK jump, ↓ held squat then stand, ← → lanes, OK twice clap) and moves a puppet
+		 * body in the frames, one child at a time. Adapt if it helps: slow down, show a selection the arrows move instead
+		 * of a hand cursor.
+		 */
+		readonly input: GameInput;
+		/**
+		 * Only with input 'remote': the remote also points (LG's Magic Remote), reaching the game as ordinary pointer and
+		 * mouse events (hover, click with OK). Then let what the game has to pick be clicked too (large hit areas, a hover
+		 * highlight). false otherwise, and from hosts that don't say. Not the pointer() adapter, which makes a child's hand
+		 * the mouse.
+		 */
+		readonly pointer: boolean;
 		/** The screen's sound is off: start the game muted. */
 		readonly muted: boolean;
 		/** The players' age range: simpler rules for 3-5, scores and challenges for 9-12. */
@@ -646,8 +784,8 @@ declare namespace FabiPlay {
 		/** Called when backdrop or view changes; returns a function that stops listening. */
 		onBackdrop(listener: (backdrop: Backdrop, view: BackdropView | null) => void): () => void;
 		/**
-		 * Listens to the host: 'frame', 'gesture', 'pause', 'resume', 'break-start', 'break-done', 'backdrop' (see
-		 * Events). Returns a function that stops listening.
+		 * Listens to the host: 'frame', 'gesture', 'pause', 'resume', 'break-start', 'break-done', 'backdrop', 'turn'
+		 * (see Events). Returns a function that stops listening.
 		 *
 		 * @example
 		 * const off = play.on('frame', (f) => (players = f.players))
@@ -658,9 +796,10 @@ declare namespace FabiPlay {
 		/** A player's score so far, for the screen to show. */
 		score(player: number, score: number): void;
 		/**
-		 * The game has stopped by itself: a level is over or the game is over (never its pause menu). Fabi Play may show
-		 * an ad there, if its rules allow (break-start, then break-done); resolves when the game can go on, true if an
-		 * ad was shown. Never call it in the middle of play.
+		 * The game has stopped by itself: a level is over, the game is over, or (with the remote, see turns) a child's
+		 * round is over and the next child's turn is due: 'turn' (never at its pause menu). Fabi Play may show an ad
+		 * there, if its rules allow (break-start, then break-done; with 'turn', the turn message in between); resolves
+		 * when the game can go on, true if an ad was shown. Never call it in the middle of play.
 		 */
 		break(reason?: BreakReason): Promise<boolean>;
 		/**