@fabi-play/sdk 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 // @fabi-play/sdk: what a game imports. See https://docs.fabiplay.app.
 // Generated by scripts/types.mjs from the sources: do not edit.
 
-/** 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">>;
 /**
  * Mutes the game while Fabi Play shows an ad, without the game doing anything: every <audio> and <video> in the page
  * pauses, every Web Audio context is suspended, and all resume afterwards. Contexts are seen only if this runs
@@ -37,7 +37,11 @@ export interface KeyTarget {
 export declare const domKeys: (doc?: Document) => KeyTarget;
 /** 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;
@@ -99,10 +103,15 @@ export type Wire<T> = T & {
 /**
  * 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;
@@ -157,7 +166,9 @@ export type Backdrop = "video" | "none";
  * 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 {
@@ -200,6 +211,22 @@ export type HostMessage =
 /** 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;
@@ -212,8 +239,11 @@ export type HostMessage =
 	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;
@@ -252,6 +282,19 @@ export type HostMessage =
  | {
 	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";
@@ -347,7 +390,39 @@ export interface GameManifest {
 	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. */
@@ -391,6 +466,10 @@ export interface Box {
  * points (amount 0–1: how much of the new frame to take), and a point seen in the last frame stays visible until
  * its visibility drops well below the threshold. Keep the result per player and pass it back as prev.
  *
+ * The easing follows the speed: a point that barely moves (a still arm, where the camera's points only tremble)
+ * takes a small share of amount, down to STILL_SHARE, so a resting arm stays still instead of wobbling; a point that
+ * moves STILL_FULL or more in a frame takes all of amount, so real movements are not delayed.
+ *
  * The face (nose, eyes, ears, mouth: what places and tilts the head) is smoothed much more, and relative to the
  * shoulders: the head follows the body at once when the child moves, but face-point noise and small nods barely
  * move it.
@@ -471,12 +550,12 @@ export type SmoothedBody = (who: PlayerFrame | number, options?: Pick<DrawAvatar
 export declare function avatarDrawer(book: AvatarBook, scene: () => {
 	view: BackdropView | null;
 }): DrawAvatar;
-/** 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. */
@@ -487,6 +566,12 @@ export interface StartInfo {
 	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,
@@ -538,6 +623,13 @@ export type EasyEvents = {
 		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;
@@ -554,7 +646,7 @@ export type EasyEvent = keyof EasyEvents;
 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
@@ -563,11 +655,14 @@ export interface Easy {
 	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;
@@ -586,6 +681,14 @@ export interface Easy {
 	 * 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. */
@@ -653,6 +756,14 @@ export type Events = {
 	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,
@@ -668,8 +779,39 @@ export interface Play {
 	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. */
@@ -731,8 +873,8 @@ export interface Play {
 	/** 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))
@@ -743,9 +885,10 @@ export interface Play {
 	/** 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>;
 	/**

package/dist/index.js

@@ -8,11 +8,13 @@ import {
   isAvatarId,
   parseDeviceHint,
   parseGameStats,
+  parseTurnOrder,
+  parseTurnPlayers,
   parseView,
   smoothBody,
   toScreen,
   wire
-} from "./chunks/chunk-57WXWAXG.js";
+} from "./chunks/chunk-GFNOIOSX.js";
 
 // src/adapters.ts
 function muteDuringBreaks(play, win = window) {
@@ -82,7 +84,8 @@ var domKeys = (doc = document) => ({
 var TAP_MS = 80;
 var MAX_HOLD_MS = 800;
 function keyboard(play, map = DEFAULT_KEYS, options = {}) {
-  const player = options.player ?? 1;
+  const follow = options.player === void 0 && play.input === "remote";
+  let player = options.player ?? (follow ? play.players?.[0] ?? 1 : 1);
   const target = options.target ?? domKeys();
   const later = options.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
   const held = /* @__PURE__ */ new Set();
@@ -138,7 +141,17 @@ function keyboard(play, map = DEFAULT_KEYS, options = {}) {
     if (p.shape === "arms-up") down("arms-up");
     else up("arms-up");
   };
-  const offs = [play.on("gesture", onGesture), play.on("frame", onFrame), play.on("break-start", () => [...held].forEach(up))];
+  const offs = [
+    play.on("gesture", onGesture),
+    play.on("frame", onFrame),
+    play.on("break-start", () => [...held].forEach(up)),
+    play.on("turn", (m) => {
+      if (!follow) return;
+      [...held].forEach(up);
+      player = m.players[0] ?? player;
+      lane = 0;
+    })
+  ];
   return () => {
     offs.forEach((off) => off());
     [...held].forEach(up);
@@ -313,6 +326,8 @@ function easy(connecting) {
   const listeners = /* @__PURE__ */ new Map();
   const emit = (event, data) => listeners.get(event)?.forEach((l) => l(data));
   let play = null;
+  let start = null;
+  const scores = /* @__PURE__ */ new Map();
   const queue = [];
   const withPlay = (fn) => play ? fn(play) : queue.push(fn);
   const early = new AvatarBook();
@@ -326,6 +341,7 @@ function easy(connecting) {
     p.on("break-start", () => emit("break-start", {}));
     p.on("break-done", (m) => emit("break-end", { shown: m.shown }));
     p.onBackdrop((backdrop, view) => emit("backdrop", { backdrop, view }));
+    p.on("turn", (m) => emit("turn", { players: [...m.players] }));
     p.on("frame", (f) => {
       emit("players", { players: f.players });
       for (const pl of f.players) {
@@ -336,7 +352,8 @@ function easy(connecting) {
         }
       }
     });
-    emit("start", startInfo(p));
+    start = startInfo(p);
+    emit("start", start);
     queue.splice(0).forEach((fn) => fn(p));
   });
   return {
@@ -344,17 +361,33 @@ function easy(connecting) {
       const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
       listeners.set(event, set);
       set.add(listener);
-      if (event === "start" && play) listener(startInfo(play));
+      if (event === "start" && start) listener(start);
       return () => void set.delete(listener);
     },
     ready: () => withPlay((p) => p.ready()),
-    score: (score, player = 1) => withPlay((p) => p.score(player, score)),
+    score: (score, player) => withPlay((p) => {
+      const who = player ?? playingNow(p);
+      scores.set(who, score);
+      p.score(who, score);
+    }),
     break: (reason) => new Promise((resolve) => withPlay((p) => void p.break(reason).then(resolve))),
     end: (score) => withPlay(
-      (p) => p.end(typeof score === "number" ? [{ player: 1, score, stars: 2 }] : score.map((s) => ({ player: s.player, score: s.score, stars: s.stars ?? 2 })))
+      (p) => p.end(typeof score === "number" ? endOf(p, score, scores) : score.map((s) => ({ player: s.player, score: s.score, stars: s.stars ?? 2 })))
     ),
     keys: (map, options) => withPlay((p) => void keyboard(p, map, options)),
     pointer: (options) => withPlay((p) => void pointer(p, options)),
+    get players() {
+      return play?.players ?? none;
+    },
+    get turns() {
+      return play?.turns ?? none;
+    },
+    get input() {
+      return play?.input ?? "body";
+    },
+    get hasPointer() {
+      return play?.pointer ?? false;
+    },
     get view() {
       return play?.view ?? null;
     },
@@ -368,7 +401,15 @@ function easy(connecting) {
     smoothedBody: (...args) => play ? play.smoothedBody(...args) : early.smoothedBody(...args)
   };
 }
-var startInfo = (p) => ({ ageRange: p.ageRange, players: p.players, locale: p.locale, mode: p.mode, backdrop: p.backdrop, view: p.view, device: p.device });
+var none = Object.freeze([]);
+var startInfo = (p) => ({ ageRange: p.ageRange, players: p.players, locale: p.locale, mode: p.mode, backdrop: p.backdrop, view: p.view, device: p.device, turns: p.turns, input: p.input, pointer: p.pointer });
+var playingNow = (p) => p.input === "remote" ? p.players[0] ?? 1 : 1;
+function endOf(p, score, last) {
+  const now = playingNow(p);
+  if (p.input !== "remote") return [{ player: now, score, stars: 2 }];
+  const played = p.turns.slice(0, Math.max(p.turns.indexOf(now), 0));
+  return [...played.map((player) => ({ player, score: last.get(player) ?? 0, stars: 2 })), { player: now, score, stars: 2 }];
+}
 
 // src/index.ts
 var windowChannel = (win = window) => ({
@@ -382,9 +423,14 @@ function connect(channel = windowChannel()) {
   return new Promise((resolve, reject) => {
     const listeners = /* @__PURE__ */ new Map();
     const breaks = [];
+    let inBreak = false;
+    let turned = false;
     let started = false;
     let backdrop = "none";
     let view = null;
+    let input = "body";
+    let players = Object.freeze([]);
+    let turns = players;
     const backdropListeners = /* @__PURE__ */ new Set();
     const avatars = new AvatarBook();
     const drawAvatar2 = avatarDrawer(avatars, () => ({ view }));
@@ -403,6 +449,11 @@ function connect(channel = windowChannel()) {
         backdrop = m.backdrop === "video" ? "video" : "none";
         view = parseView(m.view) ?? null;
         const device = parseDeviceHint(m.device) ?? null;
+        input = m.input === "remote" ? "remote" : "body";
+        const pointer2 = input === "remote" && m.pointer === true;
+        players = Object.freeze(Array.isArray(m.players) ? [...m.players] : []);
+        const order = input === "remote" && players.length === 1 ? parseTurnOrder(m.turns) : void 0;
+        turns = Object.freeze(order && order[0] === players[0] ? order : [...players]);
         let reported = {};
         if (m.stats === true) {
           let since = performance.now();
@@ -416,7 +467,12 @@ function connect(channel = windowChannel()) {
         resolve({
           locale: m.locale,
           mode: m.mode,
-          players: m.players,
+          get players() {
+            return players;
+          },
+          turns,
+          input,
+          pointer: pointer2,
           muted: m.muted,
           ageRange: m.ageRange ?? "6-8",
           get backdrop() {
@@ -446,7 +502,7 @@ function connect(channel = windowChannel()) {
           ready: () => channel.post(wire({ type: "ready" })),
           score: (player, score) => channel.post(wire({ type: "score", player, score })),
           break: (reason = "level") => new Promise((done) => {
-            breaks.push(done);
+            breaks.push({ reason, done });
             channel.post(wire({ type: "break", reason }));
           }),
           end: (scores) => channel.post(wire({ type: "end", scores }))
@@ -464,8 +520,20 @@ function connect(channel = windowChannel()) {
           message = { type: "backdrop", backdrop, ...view ? { view } : {} };
           for (const l of [...backdropListeners]) l(backdrop, view);
         }
+        if (m.type === "turn") {
+          const next = input === "remote" && inBreak && !turned && breaks[0]?.reason === "turn" ? parseTurnPlayers(m.players) : void 0;
+          const now = players[0];
+          if (!next || now === void 0 || turns.indexOf(next[0]) <= turns.indexOf(now)) return;
+          turned = true;
+          players = Object.freeze(next);
+          message = { type: "turn", players: [...next] };
+        }
+        if (m.type === "break-start") inBreak = breaks.length > 0;
         for (const l of listeners.get(m.type) ?? []) l(message);
-        if (m.type === "break-done") breaks.shift()?.(m.shown);
+        if (m.type === "break-done") {
+          inBreak = turned = false;
+          breaks.shift()?.done(m.shown);
+        }
       }
     });
   });

package/dist/integrity.json

@@ -1,12 +1,12 @@
 {
   "package": "@fabi-play/sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "algorithm": "sha384",
   "files": {
-    "fabi-play.js": "sha384-q1iuDi35LU3t+xtPL5vtoWd2pTTjZeKeNdtsickjpqwRGrkIqVxG48cIaGUWCoFP",
-    "fabi-play.umd.js": "sha384-XhDlQuvhNDkT6sTpHWV3o24704da4bk5EfH4Jq3ofz+rg3C+QNu6git9XB/icMI5",
-    "fabi-play.umd.min.js": "sha384-nyM7yG3J5Dt/2g00hGsZSe/eiMTrk7bQRYtQ0CIZhB0WJoO0aGjb7T8yy6Yr3nG4",
-    "fabi-play.d.ts": "sha384-V23/J4JFAiTVaw+nSfWHhsRyWELfql7EU5mhtQd/caA3qpNyNr2Dz6Hb8I6Lu3Zl",
-    "fabi-play.schema.json": "sha384-dLS2VzWC6Q+BI64galOdzvfoycQ+n6KjFXIajrirk15dwjvAgrDMuszeld/BhQgc"
+    "fabi-play.js": "sha384-GQRWKvHJbNMap9RaUmZb53cutIjP+4znP6K2qV33TDz7CuB8tUEKWb8b6rIr0kDZ",
+    "fabi-play.umd.js": "sha384-GARYP8mvinQoV9l0yqHQUr6tz8dSGhHtBVCJvJT3vgzbaeheds0DbMwb4TORJkE7",
+    "fabi-play.umd.min.js": "sha384-EsqeNcQaqmkU5zfOtErKZwQdxoWhm8M5t7ra10U0o0IKRHQw37CyNC5BpLogDSHw",
+    "fabi-play.d.ts": "sha384-D99Rlv+HHC7+UQlLqOJreHqt6JDVMzzxuJbXIBVmB4I+WFER2ELU/ESCiX5qT9T6",
+    "fabi-play.schema.json": "sha384-R70ay7ddz0QDzU+YN5CiyiVSeCDdoGymdVNbbSBPUOQgDpAh4ajinUGzRLa5qq7y"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabi-play/sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "What a game imports: players, movements and the end of the game, from inside its sandboxed frame.",
   "keywords": [
     "fabi-play",
@@ -36,8 +36,8 @@
     "access": "public"
   },
   "devDependencies": {
-    "@fabi-play/avatars": "^0.2.0",
-    "@fabi-play/protocol": "^0.2.0",
+    "@fabi-play/avatars": "^0.3.0",
+    "@fabi-play/protocol": "^0.3.0",
     "dts-bundle-generator": "9.5.1",
     "esbuild": "0.28.2",
     "tsx": "4.23.15",