@fabi-play/protocol 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,605 @@
+// src/sha256.ts
+function utf8(s) {
+  const out = [];
+  for (let i = 0; i < s.length; i++) {
+    let c = s.charCodeAt(i);
+    if (c >= 55296 && c <= 56319 && i + 1 < s.length) {
+      const d = s.charCodeAt(i + 1);
+      if (d >= 56320 && d <= 57343) {
+        c = 65536 + (c - 55296 << 10) + (d - 56320);
+        i++;
+      }
+    }
+    if (c >= 55296 && c <= 57343) c = 65533;
+    if (c < 128) out.push(c);
+    else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+    else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+    else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+  }
+  return Uint8Array.from(out);
+}
+var K = Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256(bytes) {
+  const blocks = Math.ceil((bytes.length + 9) / 64);
+  const data = new Uint8Array(blocks * 64);
+  data.set(bytes);
+  data[bytes.length] = 128;
+  const view = new DataView(data.buffer);
+  const bits = bytes.length * 8;
+  view.setUint32(data.length - 8, Math.floor(bits / 4294967296));
+  view.setUint32(data.length - 4, bits >>> 0);
+  const h = Uint32Array.from([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const w = new Uint32Array(64);
+  for (let off = 0; off < data.length; off += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(off + t * 4);
+    for (let t = 16; t < 64; t++) {
+      const a2 = w[t - 15];
+      const b2 = w[t - 2];
+      const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
+      const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 | 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]];
+    for (let t = 0; t < 64; t++) {
+      const t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[t] + w[t] | 0;
+      const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] = h[0] + a;
+    h[1] = h[1] + b;
+    h[2] = h[2] + c;
+    h[3] = h[3] + d;
+    h[4] = h[4] + e;
+    h[5] = h[5] + f;
+    h[6] = h[6] + g;
+    h[7] = h[7] + hh;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) outView.setUint32(i * 4, h[i]);
+  return out;
+}
+
+// src/index.ts
+var PROTOCOL_VERSION = 1;
+var LANDMARKS = 33;
+var P = {
+  nose: 0,
+  leftShoulder: 11,
+  rightShoulder: 12,
+  leftElbow: 13,
+  rightElbow: 14,
+  leftWrist: 15,
+  rightWrist: 16,
+  leftHip: 23,
+  rightHip: 24,
+  leftKnee: 25,
+  rightKnee: 26,
+  leftAnkle: 27,
+  rightAnkle: 28
+};
+var AGE_RANGES = ["3-5", "6-8", "9-12"];
+var isAgeRange = (v) => AGE_RANGES.includes(v);
+var youngest = (ranges) => AGE_RANGES.find((r) => ranges.includes(r)) ?? AGE_RANGES[0];
+var MAX_PLAYERS = 4;
+var PLAYER_COLORS = ["#EE6A43", "#6FA0E0", "#8CC9A0", "#C49BE0"];
+var MAX_AVATAR_LENGTH = 32;
+var isAvatarName = (v) => typeof v === "string" && v.length <= MAX_AVATAR_LENGTH && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(v);
+var DEFAULT_AVATARS_BY_AGE = {
+  "3-5": ["bunny", "bear", "panda", "penguin"],
+  "6-8": ["fox", "lion", "dragon", "unicorn"],
+  "9-12": ["robot", "astronaut", "ninja", "skater"]
+};
+var DEFAULT_AVATARS = DEFAULT_AVATARS_BY_AGE["6-8"];
+var defaultAvatarFor = (slot, ageRange) => {
+  const list = isAgeRange(ageRange) ? DEFAULT_AVATARS_BY_AGE[ageRange] : DEFAULT_AVATARS;
+  return list[Number.isInteger(slot) && slot >= 0 ? slot % list.length : 0];
+};
+var MIRROR_ENABLED = true;
+var VIDEO_STATES = ["on", "off", "blocked"];
+var VIDEO_BLOCKS = ["not-local", "game", "idle"];
+function parseFov(v) {
+  if (!isObject(v)) return void 0;
+  const ok = (n) => isNumber(n) && n >= 10 && n <= 170;
+  return ok(v.h) && ok(v.v) ? { h: v.h, v: v.v } : void 0;
+}
+function parseZone(v) {
+  if (!isObject(v)) return void 0;
+  const { min, max } = v;
+  return isNumber(min) && isNumber(max) && min > 0 && min < max && max <= 10 ? { min, max } : void 0;
+}
+var SCREEN_SIZES = [
+  { id: "32", kind: "tv", inches: 32, label: "32\u2033", cm: "81 cm", range: [24, 36] },
+  { id: "40-43", kind: "tv", inches: 43, label: "40\u201343\u2033", cm: "102\u2013109 cm", range: [36, 46] },
+  { id: "50-55", kind: "tv", inches: 55, label: "50\u201355\u2033", cm: "127\u2013140 cm", range: [46, 60] },
+  { id: "65", kind: "tv", inches: 65, label: "65\u2033", cm: "165 cm", range: [60, 70] },
+  { id: "75+", kind: "tv", inches: 75, label: "75\u2033+", cm: "190+ cm", range: [70, 120] },
+  { id: "phone", kind: "tablet", inches: 7, label: "6\u20137\u2033", cm: "15\u201318 cm", range: [4, 7.5] },
+  { id: "tablet-8", kind: "tablet", inches: 8.5, label: "8\u2033", cm: "20 cm", range: [7.5, 9.5] },
+  { id: "tablet-11", kind: "tablet", inches: 11, label: "10\u201311\u2033", cm: "25\u201328 cm", range: [9.5, 11.5] },
+  { id: "tablet-13", kind: "tablet", inches: 13, label: "12\u201313\u2033", cm: "30\u201333 cm", range: [11.5, 18] }
+];
+var isScreenSizeId = (v) => SCREEN_SIZES.some((s) => s.id === v);
+var screenSize = (id) => SCREEN_SIZES.find((s) => s.id === id);
+var screenSizesOf = (kind) => SCREEN_SIZES.filter((s) => s.kind === kind);
+function sizeForInches(inches, kind) {
+  if (!isNumber(inches)) return null;
+  return screenSizesOf(kind).find((s) => inches >= s.range[0] && inches < s.range[1])?.id ?? null;
+}
+var SCREEN_SIZE_KEY = "fabi-play.screen-size";
+var TOO_CLOSE_KEY = "fabi-play.too-close-pause";
+var PHASES = ["setup", "intro", "calibrate", "play", "pause", "break", "end"];
+var NS = "fabi-play";
+var wire = (m) => ({ ns: NS, ...m });
+var BREAK_REASONS = ["level", "gameover"];
+function parseView(v) {
+  if (!isObject(v)) return void 0;
+  const { x, y, w, h } = v;
+  return isNumber(x) && isNumber(y) && isNumber(w) && isNumber(h) && w > 0 && h > 0 ? { x, y, w, h } : void 0;
+}
+var toScreen = (view, p) => view ? { x: view.x + p.x * view.w, y: view.y + p.y * view.h } : { x: p.x, y: p.y };
+var DEVICE_TIERS = ["high", "medium", "low"];
+function parseDeviceHint(v) {
+  if (!isObject(v)) return void 0;
+  const out = {};
+  if (DEVICE_TIERS.includes(v.tier)) out.tier = v.tier;
+  if (isNumber(v.hz) && v.hz >= 20 && v.hz <= 240) out.hz = Math.round(v.hz);
+  return out.tier || out.hz ? out : void 0;
+}
+function parseGameStats(v) {
+  const out = {};
+  if (!isObject(v)) return out;
+  if (isNumber(v.fps) && v.fps >= 0 && v.fps < 1e3) out.fps = v.fps;
+  if (typeof v.renderer === "string" && /^[a-z0-9-]{1,16}$/.test(v.renderer)) out.renderer = v.renderer;
+  if (DEVICE_TIERS.includes(v.tier)) out.tier = v.tier;
+  return out;
+}
+var PAUSE_REASONS = ["user", "distance"];
+var GAME_BACKDROPS = ["video"];
+var MOVEMENTS = ["hands", "jump", "squat", "clap", "freeze", "lanes", "shapes"];
+function parseManifest(data) {
+  const errors = [];
+  const m = isObject(data) ? data : {};
+  const text = (v, max) => typeof v === "string" && v.trim().length > 0 && v.length <= max;
+  const texts = (v, max) => isObject(v) && text(v.it, max) && text(v.en, max);
+  if (!(typeof m.id === "string" && isGameId(m.id))) errors.push("id: lowercase letters, digits and hyphens");
+  if (!(typeof m.version === "string" && /^\d+\.\d+(\.\d+)?$/.test(m.version))) errors.push("version: e.g. 1.0 or 1.0.2");
+  if (!texts(m.title, 60)) errors.push("title: in Italian and English, up to 60 characters");
+  if (!texts(m.description, 300)) errors.push("description: in Italian and English, up to 300 characters");
+  if (!(Array.isArray(m.ageRanges) && m.ageRanges.length > 0 && m.ageRanges.every(isAgeRange))) errors.push(`ageRanges: at least one of ${AGE_RANGES.join(", ")}`);
+  if (!(Array.isArray(m.movements) && m.movements.length > 0 && m.movements.every((x) => MOVEMENTS.includes(x)))) errors.push(`movements: from ${MOVEMENTS.join(", ")}`);
+  const pl = isObject(m.players) ? m.players : {};
+  if (!(isNumber(pl.min) && isNumber(pl.max) && pl.min >= 1 && pl.max <= 4 && pl.min <= pl.max)) errors.push("players: min and max between 1 and 4");
+  if (!(isNumber(m.minutes) && m.minutes >= 1 && m.minutes <= 20)) errors.push("minutes: from 1 to 20");
+  if (!isGamePath(m.entry, "html")) errors.push("entry: an .html page of the game, a path relative to its address (no scheme, no leading /)");
+  if (m.sdk !== PROTOCOL_VERSION) errors.push(`sdk: this version of Fabi Play uses protocol ${PROTOCOL_VERSION}`);
+  if (m.backdrop !== void 0 && !(Array.isArray(m.backdrop) && m.backdrop.every((b) => GAME_BACKDROPS.includes(b)) && new Set(m.backdrop).size === m.backdrop.length))
+    errors.push(`backdrop: optional, from ${GAME_BACKDROPS.join(", ")}, without repeats`);
+  if (m.intro !== void 0) errors.push(...introErrors(m.intro));
+  return errors.length ? { errors } : { manifest: m };
+}
+var INTRO_MOVES = ["jump", "squat", "clap", "lane-left", "lane-right", "arms-up", "arms-wide", "arms-v", "star"];
+var INTRO_MAX_STEPS = 4;
+var INTRO_MAX_CHARS = 90;
+var LOCALES = ["it", "en"];
+var STEP_KEYS = ["say", "image", "move", "practice"];
+var UNSPEAKABLE = /[\p{Cc}\p{Cs}\u202A-\u202E\u2066-\u2069]/u;
+var sentence = (v) => typeof v === "string" && v.length > 0 && v === v.trim() && [...v.normalize("NFC")].length <= INTRO_MAX_CHARS && !UNSPEAKABLE.test(v);
+var sentences = (v) => isObject(v) && Object.keys(v).every((k) => LOCALES.includes(k)) && LOCALES.every((l) => sentence(v[l]));
+var isPlainText = (say) => LOCALES.some((l) => l in say);
+function sayErrors(say, path) {
+  const plain = `Italian and English, up to ${INTRO_MAX_CHARS} characters, no spaces around, no control characters`;
+  if (!isObject(say)) return [`${path}: ${plain}`];
+  const keys = Object.keys(say);
+  if (keys.some((k) => LOCALES.includes(k))) return sentences(say) ? [] : [`${path}: ${plain}`];
+  if (keys.length === 0 || !keys.every(isAgeRange)) return [`${path}: ${plain}, or that for one or more of ${AGE_RANGES.join(", ")}`];
+  return keys.flatMap((k) => sentences(say[k]) ? [] : [`${path}.${k}: ${plain}`]);
+}
+function introErrors(intro) {
+  const steps = isObject(intro) ? intro.steps : void 0;
+  if (!(Array.isArray(steps) && steps.length >= 1 && steps.length <= INTRO_MAX_STEPS)) return [`intro: 1 to ${INTRO_MAX_STEPS} steps`];
+  const unknown = Object.keys(intro).filter((k) => k !== "steps").map((k) => `intro.${k}: not a field of intro (only steps)`);
+  return unknown.concat(steps.flatMap((step, i) => {
+    const path = `intro.steps[${i}]`;
+    if (!isObject(step)) return [`${path}: an object with say, and an image or a move`];
+    const errors = Object.keys(step).filter((k) => !STEP_KEYS.includes(k)).map((k) => `${path}.${k}: not a field of a step (${STEP_KEYS.join(", ")})`);
+    errors.push(...sayErrors(step.say, `${path}.say`));
+    const { image, move, practice } = step;
+    if (image !== void 0 && move !== void 0) errors.push(`${path}: an image or a move, not both`);
+    else if (image === void 0 && move === void 0) errors.push(`${path}: an image or a move`);
+    if (image !== void 0 && !isGamePath(image, "jpg|png"))
+      errors.push(`${path}.image: a .jpg or .png of the game, a path relative to its address (no scheme, no leading /)`);
+    if (move !== void 0 && !INTRO_MOVES.includes(move)) errors.push(`${path}.move: one of ${INTRO_MOVES.join(", ")}`);
+    if (practice !== void 0 && typeof practice !== "boolean") errors.push(`${path}.practice: true or false`);
+    else if (practice === true && move === void 0) errors.push(`${path}.practice: only with a move`);
+    return errors;
+  }));
+}
+function parseIntro(data) {
+  if (data === void 0 || introErrors(data).length) return null;
+  const steps = data.steps.map((s) => {
+    const say = s.say;
+    const copy = Object.fromEntries(Object.entries(say).map(([k, v]) => [k, typeof v === "string" ? v : { it: v.it, en: v.en }]));
+    return {
+      say: copy,
+      ...typeof s.image === "string" ? { image: s.image } : { move: s.move },
+      ...s.practice === true ? { practice: true } : {}
+    };
+  });
+  return { steps };
+}
+function introText(say, locale, ageRange) {
+  if (isPlainText(say)) return say[locale] ?? "";
+  const at = AGE_RANGES.indexOf(ageRange);
+  const present = AGE_RANGES.filter((r) => say[r]);
+  const closest = present.reduce((best, r) => best === void 0 || Math.abs(AGE_RANGES.indexOf(r) - at) < Math.abs(AGE_RANGES.indexOf(best) - at) ? r : best, void 0);
+  return closest ? say[closest]?.[locale] ?? "" : "";
+}
+var FABI_VOICE = "fabi-v1";
+function voiceKeySync(text, locale, voice = FABI_VOICE) {
+  const hash = sha256(utf8(`${voice}
+${locale}
+${text.normalize("NFC").trim()}`));
+  return Array.from(hash.subarray(0, 16), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+var voiceKey = (text, locale, voice = FABI_VOICE) => Promise.resolve(voiceKeySync(text, locale, voice));
+var voiceUrl = (base, key, voice = FABI_VOICE) => `${base.replace(/\/+$/, "")}/voice/${voice}/${key}.mp3`;
+var gamesFor = (games, range, players = 1) => games.filter((g) => g.ageRanges.includes(range) && players >= g.players.min && players <= g.players.max);
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var SEGMENT = "[A-Za-z0-9_][A-Za-z0-9_-]*(?:\\.[A-Za-z0-9_-]+)*";
+var isGamePath = (v, ext) => typeof v === "string" && v.length <= 200 && new RegExp(`^(?:${SEGMENT}/)*${SEGMENT}\\.(?:${ext})$`).test(v);
+var isGameId = (v) => /^[a-z0-9]+(-[a-z0-9]+)*$/.test(v) && v.length <= 60;
+var isBody = (v) => Array.isArray(v) && v.length === LANDMARKS * 3 && v.every(isNumber);
+function parseGameMessage(data) {
+  if (!isObject(data) || data.ns !== NS) return null;
+  switch (data.type) {
+    case "ready":
+      return { type: "ready" };
+    case "break":
+      return { type: "break", reason: data.reason === void 0 ? "level" : BREAK_REASONS.includes(data.reason) ? data.reason : "unknown" };
+    case "score":
+      return isNumber(data.player) && isNumber(data.score) ? { type: "score", player: data.player, score: data.score } : null;
+    case "end": {
+      if (!Array.isArray(data.scores) || data.scores.length > 8) return null;
+      const scores = data.scores.flatMap(
+        (s) => isObject(s) && isNumber(s.player) && isNumber(s.score) && [0, 1, 2, 3].includes(s.stars) ? [{ player: s.player, score: s.score, stars: s.stars }] : []
+      );
+      return scores.length === data.scores.length ? { type: "end", scores } : null;
+    }
+    case "stats":
+      return isNumber(data.renderFps) && data.renderFps >= 0 && data.renderFps < 1e3 ? { type: "stats", renderFps: data.renderFps, ...parseGameStats(data) } : null;
+    default:
+      return null;
+  }
+}
+var COMMANDS = ["pause", "resume", "quit"];
+var INTRO_ACTIONS = ["next", "repeat", "skip", "replay"];
+function parseControllerMessage(data) {
+  if (!isObject(data)) return null;
+  switch (data.type) {
+    case "hello":
+      if (!(isNumber(data.v) && (data.camera === "back" || data.camera === "front") && typeof data.device === "string")) return null;
+      {
+        const fov = parseFov(data.fov);
+        return {
+          type: "hello",
+          v: data.v,
+          camera: data.camera,
+          device: data.device.slice(0, 80),
+          aspect: isNumber(data.aspect) ? Math.min(Math.max(data.aspect, 0.3), 3) : 0.75,
+          ...fov ? { fov } : {}
+        };
+      }
+    case "pose":
+      return isNumber(data.t) && Array.isArray(data.bodies) && data.bodies.length <= MAX_PLAYERS && data.bodies.every(isBody) ? { type: "pose", t: data.t, bodies: data.bodies } : null;
+    case "players": {
+      if (!Array.isArray(data.players) || data.players.length < 1 || data.players.length > MAX_PLAYERS) return null;
+      const players = data.players.flatMap(
+        (p) => isObject(p) && typeof p.name === "string" && isAgeRange(p.ageRange) ? [{ name: p.name.trim().slice(0, 20), ageRange: p.ageRange, ...isAvatarName(p.avatar) ? { avatar: p.avatar } : {} }] : []
+      );
+      if (players.length !== data.players.length) return null;
+      return typeof data.tooClosePause === "boolean" ? { type: "players", players, tooClosePause: data.tooClosePause } : { type: "players", players };
+    }
+    case "screen-size":
+      if (!isScreenSizeId(data.size)) return null;
+      return data.change === true ? { type: "screen-size", size: data.size, change: true } : { type: "screen-size", size: data.size };
+    case "pick":
+      return typeof data.game === "string" && isGameId(data.game) ? { type: "pick", game: data.game } : null;
+    case "command":
+      return COMMANDS.includes(data.command) ? { type: "command", command: data.command } : null;
+    case "intro":
+      return INTRO_ACTIONS.includes(data.action) ? { type: "intro", action: data.action } : null;
+    case "video":
+      return VIDEO_STATES.includes(data.state) ? { type: "video", state: data.state, ...VIDEO_BLOCKS.includes(data.reason) ? { reason: data.reason } : {} } : null;
+    default:
+      return null;
+  }
+}
+function parseScreenMessage(data) {
+  if (!isObject(data)) return null;
+  switch (data.type) {
+    case "welcome":
+      if (!(isNumber(data.v) && typeof data.screen === "string")) return null;
+      {
+        const binaryPose = Array.isArray(data.binaryPose) ? data.binaryPose.slice(0, 8).filter((n) => Number.isInteger(n) && n >= 1 && n <= 255) : [];
+        return { type: "welcome", v: data.v, screen: data.screen, ...binaryPose.length ? { binaryPose } : {} };
+      }
+    case "phase":
+      return PHASES.includes(data.phase) ? {
+        type: "phase",
+        phase: data.phase,
+        ...typeof data.game === "string" ? { game: data.game } : {},
+        ...data.intro === true ? { intro: true } : {}
+      } : null;
+    case "catalogue": {
+      if (!Array.isArray(data.games) || data.games.length > 50) return null;
+      const games = data.games.flatMap(
+        (g) => isObject(g) && typeof g.id === "string" && isGameId(g.id) && typeof g.title === "string" ? [{ id: g.id, title: g.title.slice(0, 60) }] : []
+      );
+      return games.length === data.games.length ? { type: "catalogue", games } : null;
+    }
+    case "vibrate":
+      return isNumber(data.ms) ? { type: "vibrate", ms: Math.min(Math.max(data.ms, 0), 500) } : null;
+    case "video-allowed":
+      return typeof data.allowed === "boolean" ? { type: "video-allowed", allowed: data.allowed, ...VIDEO_BLOCKS.includes(data.reason) ? { reason: data.reason } : {} } : null;
+    case "intro": {
+      const { step, steps, text, voice } = data;
+      if (!(Number.isInteger(step) && Number.isInteger(steps) && typeof text === "string" && typeof voice === "boolean")) return null;
+      const [s, n] = [step, steps];
+      return s >= 0 && s < n && n <= INTRO_MAX_STEPS + 1 ? { type: "intro", step: s, steps: n, text: Array.from(text.trim()).slice(0, 200).join(""), voice } : null;
+    }
+    case "screen-size": {
+      if (typeof data.ask !== "boolean") return null;
+      const zone = parseZone(data.zone);
+      return {
+        type: "screen-size",
+        ask: data.ask,
+        ...isScreenSizeId(data.size) ? { size: data.size } : {},
+        ...isScreenSizeId(data.detected) ? { detected: data.detected } : {},
+        ...typeof data.model === "string" && data.model.trim() ? { model: data.model.trim().slice(0, 40) } : {},
+        ...zone ? { zone } : {}
+      };
+    }
+    default:
+      return null;
+  }
+}
+function toPlayerSpace(points, mirrored = false) {
+  const r = (n) => Math.round(Math.min(Math.max(n, 0), 1) * 1e3) / 1e3;
+  return points.flatMap((p) => [r(mirrored ? p.x : 1 - p.x), r(p.y), r(p.visibility ?? 1)]);
+}
+var POSE_CODEC_VERSION = 1;
+var POSE_CODEC_VERSIONS = [POSE_CODEC_VERSION];
+var POSE_MAGIC = 251;
+var POSE_KIND = 1;
+var POSE_HEADER = 12;
+var POSE_BODY_BYTES = LANDMARKS * 4;
+var poseBytes = (bodies) => POSE_HEADER + bodies * POSE_BODY_BYTES;
+var POSE_MAX_BYTES = poseBytes(MAX_PLAYERS);
+var acceptsBinaryPose = (welcome) => welcome.binaryPose?.includes(POSE_CODEC_VERSION) ?? false;
+var milli = (v) => {
+  if (!Number.isFinite(v)) throw new RangeError("pose: a landmark is not a finite number");
+  return v <= 0 ? 0 : v >= 1 ? 1e3 : Math.round(v * 1e3);
+};
+var lastOut = null;
+var lastView = null;
+var viewOf = (b) => {
+  if (b !== lastOut || !lastView) {
+    lastOut = b;
+    lastView = new DataView(b.buffer, b.byteOffset, b.byteLength);
+  }
+  return lastView;
+};
+function encodePose(msg, out) {
+  const { t, bodies } = msg;
+  if (!Number.isFinite(t)) throw new RangeError("pose: t is not a finite number");
+  if (bodies.length > MAX_PLAYERS) throw new RangeError(`pose: more than ${MAX_PLAYERS} bodies`);
+  const size = poseBytes(bodies.length);
+  const bytes = out && out.byteLength >= size ? out : new Uint8Array(size);
+  const view = viewOf(bytes);
+  view.setUint8(0, POSE_MAGIC);
+  view.setUint8(1, POSE_CODEC_VERSION);
+  view.setUint8(2, POSE_KIND);
+  view.setUint8(3, bodies.length);
+  view.setFloat64(4, t, true);
+  let at = POSE_HEADER;
+  for (const body of bodies) {
+    if (body.length !== LANDMARKS * 3) throw new RangeError(`pose: a body is not ${LANDMARKS} \xD7 3 numbers`);
+    for (let i = 0; i < body.length; i += 3) {
+      view.setUint32(at, (milli(body[i]) | milli(body[i + 1]) << 10 | milli(body[i + 2]) << 20) >>> 0, true);
+      at += 4;
+    }
+  }
+  return bytes.byteLength === size ? bytes : bytes.subarray(0, size);
+}
+function decodePose(data) {
+  let view;
+  if (data instanceof ArrayBuffer) view = new DataView(data);
+  else if (ArrayBuffer.isView(data)) view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  else return null;
+  if (view.byteLength < POSE_HEADER) return null;
+  if (view.getUint8(0) !== POSE_MAGIC || !POSE_CODEC_VERSIONS.includes(view.getUint8(1)) || view.getUint8(2) !== POSE_KIND) return null;
+  const count = view.getUint8(3);
+  if (count > MAX_PLAYERS || view.byteLength !== poseBytes(count)) return null;
+  const t = view.getFloat64(4, true);
+  if (!Number.isFinite(t)) return null;
+  const bodies = [];
+  let at = POSE_HEADER;
+  for (let b = 0; b < count; b++) {
+    const body = new Array(LANDMARKS * 3);
+    for (let i = 0; i < LANDMARKS * 3; i += 3) {
+      const word = view.getUint32(at, true);
+      at += 4;
+      const x = word & 1023;
+      const y = word >>> 10 & 1023;
+      const v = word >>> 20 & 1023;
+      if (x > 1e3 || y > 1e3 || v > 1e3 || word >>> 30 !== 0) return null;
+      body[i] = x / 1e3;
+      body[i + 1] = y / 1e3;
+      body[i + 2] = v / 1e3;
+    }
+    bodies.push(body);
+  }
+  return { type: "pose", t, bodies };
+}
+var legacyStorageKey = (key) => key.startsWith("fabi-play.") ? `fablee-play.${key.slice("fabi-play.".length)}` : null;
+function migrateStorageKey(store, newKey, oldKey = legacyStorageKey(newKey)) {
+  if (!store || !oldKey) return;
+  try {
+    const old = store.getItem(oldKey);
+    if (old === null) return;
+    if (store.getItem(newKey) === null) store.setItem(newKey, old);
+    store.removeItem(oldKey);
+  } catch {
+  }
+}
+async function migrateStorageKeyAsync(store, newKey, oldKey = legacyStorageKey(newKey)) {
+  if (!oldKey) return;
+  try {
+    const old = await store.getItem(oldKey);
+    if (old === null) return;
+    if (await store.getItem(newKey) === null) await store.setItem(newKey, old);
+    await store.removeItem(oldKey);
+  } catch {
+  }
+}
+export {
+  AGE_RANGES,
+  BREAK_REASONS,
+  DEFAULT_AVATARS,
+  DEFAULT_AVATARS_BY_AGE,
+  DEVICE_TIERS,
+  FABI_VOICE,
+  GAME_BACKDROPS,
+  INTRO_MAX_CHARS,
+  INTRO_MAX_STEPS,
+  INTRO_MOVES,
+  LANDMARKS,
+  MAX_AVATAR_LENGTH,
+  MAX_PLAYERS,
+  MIRROR_ENABLED,
+  MOVEMENTS,
+  NS,
+  P,
+  PAUSE_REASONS,
+  PHASES,
+  PLAYER_COLORS,
+  POSE_CODEC_VERSION,
+  POSE_CODEC_VERSIONS,
+  POSE_MAX_BYTES,
+  PROTOCOL_VERSION,
+  SCREEN_SIZES,
+  SCREEN_SIZE_KEY,
+  TOO_CLOSE_KEY,
+  VIDEO_BLOCKS,
+  VIDEO_STATES,
+  acceptsBinaryPose,
+  decodePose,
+  defaultAvatarFor,
+  encodePose,
+  gamesFor,
+  introText,
+  isAgeRange,
+  isAvatarName,
+  isBody,
+  isGameId,
+  isScreenSizeId,
+  legacyStorageKey,
+  migrateStorageKey,
+  migrateStorageKeyAsync,
+  parseControllerMessage,
+  parseDeviceHint,
+  parseFov,
+  parseGameMessage,
+  parseGameStats,
+  parseIntro,
+  parseManifest,
+  parseScreenMessage,
+  parseView,
+  parseZone,
+  poseBytes,
+  screenSize,
+  screenSizesOf,
+  sizeForInches,
+  toPlayerSpace,
+  toScreen,
+  voiceKey,
+  voiceKeySync,
+  voiceUrl,
+  wire,
+  youngest
+};