@buoy-gg/shared-ui 7.0.32 → 7.0.34

package/lib/commonjs/ui/otto/ottoEngine.js

@@ -0,0 +1,2734 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OTTO_USES = exports.OTTO_STATE_NAMES = exports.OTTO_STATES = exports.OTTO_REEL = exports.OTTO_PALETTE = exports.OTTO_NOTES = exports.OTTO_GROUPS = exports.OTTO_GRID = exports.OTTO_ANCHOR_SIZE = exports.OTTO_ANCHORS = void 0;
+exports.ottoReel = ottoReel;
+exports.ottoRuns = ottoRuns;
+exports.ottoWaterRows = ottoWaterRows;
+exports.renderOttoFrame = renderOttoFrame;
+/**
+ * Otto — Buoy's pixel mascot, ported 1:1 from the Claude Design mockup
+ * (`Otto.dc.html`, "Turn 6 — Otto, full state set").
+ *
+ * Everything here is pure: a pose is a parametric description (body rect,
+ * lamp, eyes, legs, prop extras) baked onto a 16×16 grid, composed with a
+ * keyline and water, then painted from the palette. No React, no timers —
+ * `renderOttoFrame(state, t)` is the whole API, so it can be lifted into a
+ * package unchanged. `OttoSprite.tsx` is the React Native renderer.
+ */
+
+const OTTO_GRID = exports.OTTO_GRID = 16;
+
+/** Palette keys → colours. `.` is transparent. */
+const OTTO_PALETTE = exports.OTTO_PALETTE = {
+  g: "#20C997",
+  // body
+  s: "#1BAB80",
+  // body shade
+  d: "#0D9668",
+  // body deep (lamp base)
+  h: "#3DD9A8",
+  // body highlight (top row)
+  k: "#000000",
+  // keyline / eyes
+  a: "#FFA94D",
+  // lamp lit
+  A: "#6B4520",
+  // lamp dim
+  r: "#FF3B30",
+  // danger
+  R: "#5A1712",
+  // danger dim
+  p: "#9B70E0",
+  // purple props
+  w: "#0A1A16",
+  // water
+  W: "#0F2A22",
+  // water crest
+  n: "#9BA1A6",
+  // prop light grey
+  m: "#636366",
+  // prop mid grey
+  l: "#ECEDEE",
+  // prop white
+  "1": "#2A2A2E" // prop dark
+};
+
+/** [x, y, paletteKey] */
+
+const BASE = {
+  x0: 3,
+  y0: 4,
+  w: 10,
+  h: 7,
+  eyes: "open",
+  lamp: "a",
+  legs: [0, 0, 0]
+};
+
+// Keys that count as "body" for the keyline pass. Props (n/m/l/p/1) get none.
+const BODY_KEYS = "gsdhaArRk";
+function walk(t) {
+  return t % 2 ? [0, 1, 0] : [1, 0, 1];
+}
+function rect(x0, y0, x1, y1, c, out) {
+  for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) out.push([x, y, c]);
+  return out;
+}
+function pt([x, y], c) {
+  return [x, y, c];
+}
+
+/** A 4×5 loop at the top right, clockwise from the top left — spinners orbit it. */
+const RING = [[13, 0], [14, 0], [15, 1], [15, 2], [15, 3], [14, 4], [13, 4], [12, 3], [12, 2], [12, 1]];
+
+/** A 3-wide arrow pointing down, tip at `y + 3`; parts above row 0 are clipped. */
+function arrowDown(x, y, c, out) {
+  out.push([x, y, c], [x, y + 1, c], [x - 1, y + 2, c], [x, y + 2, c], [x + 1, y + 2, c], [x, y + 3, c]);
+  return out;
+}
+
+/** A 3-wide arrow pointing up, tip at `y`. */
+function arrowUp(x, y, c, out) {
+  out.push([x, y, c], [x - 1, y + 1, c], [x, y + 1, c], [x + 1, y + 1, c], [x, y + 2, c], [x, y + 3, c]);
+  return out;
+}
+
+/** Morse S-O-S, one tick per unit: dot 1, dash 3, gaps 1/2, word pause 6. */
+const SOS = [1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0];
+
+/** A padlock at the right edge (x 13–15): orange body, grey shackle, keyhole. */
+function padlock(open, out) {
+  rect(13, 4, 15, 6, "a", out);
+  out.push([14, 5, "k"], [14, 6, "k"]);
+  if (open) out.push([13, 1, "n"], [14, 1, "n"], [15, 1, "n"], [13, 2, "n"], [13, 3, "n"]);else out.push([13, 2, "n"], [14, 2, "n"], [15, 2, "n"], [13, 3, "n"], [15, 3, "n"]);
+  return out;
+}
+
+/** Bake a pose onto the grid as palette keys (`.` = empty). */
+function draw(p) {
+  const W = OTTO_GRID;
+  const H = OTTO_GRID;
+  const g = Array.from({
+    length: H
+  }, () => Array(W).fill("."));
+  const dx = p.dx || 0;
+  const put = (x, y, c) => {
+    x += dx;
+    if (x >= 0 && x < W && y >= 0 && y < H) g[y][x] = c;
+  };
+  const {
+    x0,
+    y0,
+    w,
+    h
+  } = p;
+  const x1 = x0 + w - 1;
+  const y1 = y0 + h - 1;
+  for (let y = y0; y <= y1; y++) {
+    for (let x = x0; x <= x1; x++) {
+      if ((x === x0 || x === x1) && (y === y0 || y === y1)) continue;
+      put(x, y, y === y0 ? "h" : y === y1 || x === x1 ? "s" : "g");
+    }
+  }
+  if (p.lamp) {
+    const cx = x0 + Math.floor(w / 2) - 1;
+    put(cx, y0 - 2, p.lamp);
+    put(cx + 1, y0 - 2, p.lamp);
+    for (let x = cx - 1; x <= cx + 2; x++) put(x, y0 - 1, "d");
+  }
+  const ex = p.ex || 0;
+  const ey = y0 + 2 + (p.ey || 0);
+  for (const e of [x0 + 2 + ex, x1 - 3 + ex]) {
+    if (p.eyes === "open") {
+      put(e, ey, "k");
+      put(e + 1, ey, "k");
+      put(e, ey + 1, "k");
+      put(e + 1, ey + 1, "k");
+    } else if (p.eyes === "closed") {
+      put(e, ey + 1, "k");
+      put(e + 1, ey + 1, "k");
+    } else if (p.eyes === "happy") {
+      put(e, ey + 1, "k");
+      put(e + 1, ey, "k");
+      put(e + 2, ey + 1, "k");
+    } else if (p.eyes === "x") {
+      put(e, ey, "k");
+      put(e + 2, ey, "k");
+      put(e + 1, ey + 1, "k");
+      put(e, ey + 2, "k");
+      put(e + 2, ey + 2, "k");
+    } else if (p.eyes === "big") {
+      for (let yy = 0; yy < 3; yy++) for (let xx = 0; xx < 3; xx++) put(e + xx, ey + yy, "k");
+    }
+  }
+  if (p.legs) {
+    const start = x0 + Math.floor((w - 8) / 2);
+    p.legs.forEach((o, i) => {
+      const lx = start + i * 3;
+      put(lx, y1 + 1, o ? "s" : "g");
+      put(lx + 1, y1 + 1, o ? "s" : "g");
+      if (!o) {
+        put(lx, y1 + 2, "s");
+        put(lx + 1, y1 + 2, "s");
+      }
+    });
+  }
+  (p.extras || []).forEach(([x, y, c]) => put(x, y, c));
+  return g;
+}
+function wave(x, y, t) {
+  return ((x - Math.floor(t / 2) + y * 5) % 7 + 7) % 7 < 2 ? "W" : "w";
+}
+
+/** The water on its own: rows 13–15 as palette keys at tick `t`. Period 7 in floor(t/2). */
+function ottoWaterRows(t) {
+  const rows = [];
+  for (let y = 13; y < OTTO_GRID; y++) {
+    const row = [];
+    for (let x = 0; x < OTTO_GRID; x++) row.push(wave(x, y, t));
+    rows.push(row);
+  }
+  return rows;
+}
+const NEIGHBOURS = [[0, 1], [0, -1], [1, 0], [-1, 0]];
+/** Keyline around the body, water in the bottom three rows. */
+function compose(g, t, o) {
+  const W = OTTO_GRID;
+  const H = OTTO_GRID;
+  const out = g.map(r => r.slice());
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      const under = y >= 13;
+      if (under && o.submerged) {
+        out[y][x] = o.water ? wave(x, y, t) : ".";
+        continue;
+      }
+      if (g[y][x] !== ".") continue;
+      const nb = o.keyline && NEIGHBOURS.some(([dy, ddx]) => {
+        const yy = y + dy;
+        const xx = x + ddx;
+        return yy >= 0 && yy < H && xx >= 0 && xx < W && BODY_KEYS.includes(g[yy][xx]);
+      });
+      if (nb) out[y][x] = "k";else if (under && o.water) out[y][x] = wave(x, y, t);
+    }
+  }
+  return out;
+}
+const OTTO_STATES = exports.OTTO_STATES = {
+  idle: t => {
+    const c = t % 48;
+    const bob = c % 8 >= 4 ? 1 : 0;
+    const blink = c % 16 === 13 || c === 47;
+    const ex = c >= 20 && c <= 26 ? -1 : c >= 32 && c <= 38 ? 1 : 0;
+    return {
+      ...BASE,
+      y0: 4 + bob,
+      eyes: blink ? "closed" : "open",
+      ex,
+      legs: walk(Math.floor(t / 2))
+    };
+  },
+  thinking: t => {
+    const c = t % 10;
+    const e = [];
+    if (c >= 1) e.push([13, 5, "n"]);
+    if (c >= 2) e.push([14, 3, "n"]);
+    if (c >= 3) {
+      rect(11, 0, 14, 0, "l", e);
+      rect(10, 1, 15, 1, "l", e);
+      rect(11, 2, 14, 2, "l", e);
+    }
+    for (let i = 0; i < Math.min(3, Math.max(0, c - 4)); i++) e.push([11 + i * 2, 1, "m"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      lamp: t % 4 < 2 ? "a" : "A",
+      extras: e
+    };
+  },
+  happy: t => {
+    const c = t % 12;
+    const hop = [0, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0][c];
+    let p = {
+      ...BASE,
+      eyes: "happy",
+      legs: walk(t),
+      y0: 4 - hop
+    };
+    if (c === 1) p = {
+      ...p,
+      x0: 4,
+      w: 8,
+      h: 8,
+      y0: 2
+    };
+    if (c === 5 || c === 6) p = {
+      ...p,
+      x0: 2,
+      w: 12,
+      h: 6,
+      y0: 5
+    };
+    return p;
+  },
+  error: t => ({
+    ...BASE,
+    lamp: t % 2 ? "r" : "R",
+    dx: [0, 1, 0, -1][t % 4],
+    eyes: "closed"
+  }),
+  sleep: t => {
+    const ph = Math.floor(t / 3) % 4;
+    const z = (x, y) => [[x, y], [x + 1, y], [x + 2, y], [x + 3, y], [x + 2, y + 1], [x + 1, y + 2], [x, y + 3], [x + 1, y + 3], [x + 2, y + 3], [x + 3, y + 3]].map(([a, b]) => [a, b, "n"]);
+    return {
+      ...BASE,
+      y0: 5 + Math.floor(t / 8) % 2,
+      eyes: "closed",
+      lamp: "A",
+      extras: z(12, 6 - ph * 2)
+    };
+  },
+  peek: t => ({
+    ...BASE,
+    submerged: true,
+    y0: 9 + Math.floor(t / 4) % 2,
+    ex: [-1, 0, 1, 0][Math.floor(t / 6) % 4],
+    legs: null
+  }),
+  typing: t => {
+    const e = [];
+    rect(3, 8, 12, 8, "n", e);
+    rect(3, 11, 12, 11, "n", e);
+    rect(3, 9, 3, 10, "n", e);
+    rect(12, 9, 12, 10, "n", e);
+    rect(4, 9, 11, 10, "1", e);
+    rect(7, 9, 8, 10, "g", e);
+    rect(2, 12, 13, 12, "m", e);
+    const tap = t % 2;
+    e.push([2, 10 + tap, "g"], [13, 11 - tap, "g"]);
+    return {
+      ...BASE,
+      eyes: t % 12 === 11 ? "closed" : "open",
+      legs: null,
+      extras: e
+    };
+  },
+  debugging: t => {
+    const gx = Math.floor(t / 4) % 2 ? 0 : -1;
+    const e = [];
+    [[10, 3], [11, 3], [12, 3], [9, 4], [13, 4], [9, 5], [13, 5], [9, 6], [13, 6], [10, 7], [11, 7], [12, 7]].forEach(([x, y]) => e.push([x + gx, y, "n"]));
+    rect(10 + gx, 4, 12 + gx, 4, "l", e);
+    rect(10 + gx, 5, 12 + gx, 6, "k", e);
+    e.push([14 + gx, 7, "m"], [15 + gx, 8, "m"]);
+    return {
+      ...BASE,
+      extras: e
+    };
+  },
+  building: t => {
+    const e = [];
+    rect(5, 1, 10, 1, "a", e);
+    rect(4, 2, 11, 2, "a", e);
+    rect(2, 3, 13, 3, "A", e);
+    rect(13, 11, 15, 12, "m", e);
+    if (t % 4 < 2) e.push([13, 6, "g"], [14, 5, "m"], [14, 4, "m"], [13, 2, "n"], [14, 2, "n"], [15, 2, "n"]);else e.push([13, 8, "g"], [14, 9, "m"], [15, 8, "n"], [15, 9, "n"], [15, 10, "n"], [12, 10, "a"]);
+    return {
+      ...BASE,
+      lamp: null,
+      eyes: t % 10 === 9 ? "closed" : "open",
+      extras: e
+    };
+  },
+  carrying: t => {
+    const b = t % 4 < 2 ? 0 : 1;
+    const e = [];
+    rect(5, b, 10, b, "n", e);
+    rect(5, 3 + b, 10, 3 + b, "n", e);
+    rect(5, 1 + b, 5, 2 + b, "n", e);
+    rect(10, 1 + b, 10, 2 + b, "n", e);
+    rect(6, 1 + b, 9, 2 + b, "g", e);
+    rect(4, 2 + b, 4, 3 + b, "g", e);
+    rect(11, 2 + b, 11, 3 + b, "g", e);
+    return {
+      ...BASE,
+      y0: 4 + b,
+      lamp: null,
+      ey: -1,
+      legs: walk(t),
+      extras: e
+    };
+  },
+  pushing: t => {
+    const e = [];
+    for (let y = 5; y <= 12; y++) {
+      for (let x = 11; x <= 15; x++) {
+        e.push([x, y, y === 5 || y === 12 || x === 11 || x === 15 ? "n" : x === 13 ? "l" : "m"]);
+      }
+    }
+    e.push([10, 7, "g"], [10, 8, "g"]);
+    return {
+      ...BASE,
+      x0: 0,
+      dx: t % 4 < 2 ? 0 : 1,
+      ex: 1,
+      legs: walk(t),
+      extras: e
+    };
+  },
+  sweeping: t => {
+    const s = t % 4 < 2 ? 0 : 1;
+    const e = [];
+    rect(13, 3, 13, 10, "m", e);
+    rect(12 + s, 11, 15 + s, 12, "a", e);
+    e.push([13, 6, "g"]);
+    if (s) e.push([15, 10, "m"], [11, 12, "m"]);
+    return {
+      ...BASE,
+      ex: 1,
+      eyes: t % 12 === 11 ? "closed" : "open",
+      extras: e
+    };
+  },
+  juggling: t => {
+    const e = [];
+    [[2, "r"], [7, "a"], [12, "p"]].forEach(([x, c], i) => {
+      const h = [0, 1, 2, 2, 1, 0][(t + i * 2) % 6];
+      const y = 2 - h;
+      rect(x, y, x + 1, y + 1, c, e);
+    });
+    e.push([2, 4 + t % 2, "g"], [13, 5 - t % 2, "g"]);
+    return {
+      ...BASE,
+      lamp: null,
+      ey: -1,
+      ex: [-1, 0, 1, 0][Math.floor(t / 2) % 4],
+      extras: e
+    };
+  },
+  wizard: t => {
+    const e = [];
+    rect(7, 0, 8, 0, "p", e);
+    rect(6, 1, 9, 1, "p", e);
+    rect(5, 2, 10, 2, "p", e);
+    rect(3, 3, 12, 3, "p", e);
+    e.push([8, 1, "a"]);
+    e.push([13, 5, "g"], [14, 4, "m"], [15, 3, "m"]);
+    const sp = t % 4;
+    if (sp === 1) e.push([15, 1, "a"]);
+    if (sp === 2) e.push([14, 1, "a"], [15, 0, "a"], [15, 2, "a"]);
+    if (sp === 3) e.push([13, 0, "a"]);
+    return {
+      ...BASE,
+      lamp: null,
+      eyes: t % 12 === 11 ? "closed" : "open",
+      extras: e
+    };
+  },
+  conducting: t => {
+    const u = t % 2;
+    const n = Math.floor(t / 2) % 4;
+    const e = [[1, 4 + u * 3, "g"], [2, 4 + u * 3, "g"], [13, 7 - u * 3, "g"], [14, 7 - u * 3, "g"], [15, 6 - u * 3, "m"], [2, 3 - n, "n"], [3, 2 - n, "n"]];
+    return {
+      ...BASE,
+      eyes: "happy",
+      extras: e
+    };
+  },
+  beacon: t => {
+    const f = t % 6;
+    const rings = [[], [[5, 3], [10, 3], [5, 2], [10, 2]], [[3, 3], [12, 3], [3, 2], [12, 2], [4, 1], [11, 1], [5, 0], [10, 0]], [[1, 2], [14, 2], [1, 1], [14, 1], [2, 0], [13, 0]], [], []];
+    return {
+      ...BASE,
+      lamp: f < 4 ? "a" : "A",
+      ey: -1,
+      extras: rings[f].map(([x, y]) => [x, y, "a"])
+    };
+  },
+  notification: t => {
+    const c = t % 16;
+    const hop = [0, 0, 0, 0, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0][c];
+    const show = c >= 3 && c <= 10;
+    const e = show ? [...rect(14, 0, 15, 2, "a", []), [14, 4, "a"], [15, 4, "a"]] : [];
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      lamp: show && c % 2 ? "A" : "a",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  disconnected: t => {
+    const on = t % 4 < 2;
+    const e = [];
+    for (let y = 0; y <= 4; y++) {
+      e.push([12, y, "n"], [14, y, "n"], [13, y, y === 0 || y === 4 ? "n" : on ? "r" : "1"]);
+    }
+    return {
+      ...BASE,
+      y0: 5,
+      lamp: "A",
+      ex: 1,
+      ey: -1,
+      extras: e
+    };
+  },
+  dizzy: t => {
+    const pos = [[1, 2], [4, 0], [11, 0], [14, 2]];
+    const s = [pos[t % 4], pos[(t + 2) % 4]].map(([x, y]) => [x, y, "a"]);
+    return {
+      ...BASE,
+      eyes: "x",
+      lamp: "A",
+      dx: [0, 1, 0, -1][t % 4],
+      extras: s
+    };
+  },
+  overheated: t => {
+    const k = [0, 0, 0, 1, 2, 3, 3, 3, 3, 2, 1, 0][t % 12];
+    const shapes = [{
+      x0: 3,
+      y0: 4,
+      w: 10,
+      h: 7,
+      ey: 0,
+      legs: [0, 0, 0]
+    }, {
+      x0: 3,
+      y0: 6,
+      w: 10,
+      h: 5,
+      ey: 0,
+      legs: [0, 0, 0]
+    }, {
+      x0: 2,
+      y0: 8,
+      w: 12,
+      h: 3,
+      ey: -1,
+      legs: null
+    }, {
+      x0: 1,
+      y0: 10,
+      w: 14,
+      h: 2,
+      ey: -2,
+      legs: null
+    }];
+    return {
+      ...BASE,
+      ...shapes[k],
+      eyes: k >= 2 ? "closed" : "open",
+      lamp: k >= 2 ? "A" : t % 2 ? "a" : "A",
+      extras: k >= 1 ? [[14, 2 + t % 3, "l"]] : []
+    };
+  },
+  confused: t => {
+    const c = t % 18;
+    const e = c >= 4 ? [[12, 0, "n"], [13, 0, "n"], [14, 0, "n"], [14, 1, "n"], [13, 2, "n"], [14, 2, "n"], [13, 4, "n"]] : [];
+    return {
+      ...BASE,
+      ex: [1, 1, 0, -1, -1, 0][Math.floor(c / 3) % 6],
+      ey: -1,
+      dx: c >= 9 ? -1 : 0,
+      extras: e
+    };
+  },
+  stare: t => ({
+    ...BASE,
+    eyes: t % 20 === 19 ? "closed" : "big",
+    ex: [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0][t % 20]
+  }),
+  walking: t => {
+    const c = t % 16;
+    const pos = c < 8 ? c - 4 : 11 - c;
+    return {
+      ...BASE,
+      dx: pos,
+      ex: c < 8 ? 1 : -1,
+      legs: walk(t)
+    };
+  },
+  goingaway: t => ({
+    ...BASE,
+    dx: t % 26 - 6,
+    ex: 1,
+    legs: walk(t)
+  }),
+  eureka: t => {
+    const c = t % 24;
+    const e = [];
+    if (c >= 3 && c < 20) {
+      const on = c >= 6;
+      rect(12, 0, 13, 0, on ? "a" : "A", e);
+      rect(11, 1, 14, 2, on ? "a" : "A", e);
+      rect(12, 3, 13, 3, "m", e);
+      rect(12, 4, 13, 4, "n", e);
+      if (on) e.push([12, 1, "l"]);
+      if (on && c < 14 && c % 2 === 0) e.push([10, 0, "l"], [15, 0, "l"], [10, 4, "l"], [15, 4, "l"]);
+      e.push([13, 6, "g"], [14, 5, "g"]);
+    }
+    return {
+      ...BASE,
+      lamp: c >= 6 && c < 20 ? "a" : "A",
+      eyes: c >= 8 && c < 20 ? "happy" : c === 22 ? "closed" : "open",
+      ex: c >= 3 && c < 8 ? 1 : 0,
+      ey: c >= 3 && c < 8 ? -1 : 0,
+      y0: c >= 8 && c < 20 && c % 4 < 2 ? 3 : 4,
+      extras: e
+    };
+  },
+  grooving: t => {
+    const b = t % 4;
+    const lean = [0, 1, 0, -1][b];
+    const e = [];
+    rect(4, 1, 11, 1, "p", e);
+    rect(3, 2, 3, 3, "p", e);
+    rect(12, 2, 12, 3, "p", e);
+    rect(1, 6, 2, 8, "p", e);
+    rect(13, 6, 14, 8, "p", e);
+    e.push([2, 7, "1"], [13, 7, "1"]);
+    if (b === 1) e.push([0, 3, "a"], [1, 2, "a"], [1, 3, "a"]);
+    if (b === 3) e.push([15, 3, "a"], [14, 2, "a"], [14, 3, "a"]);
+    return {
+      ...BASE,
+      lamp: null,
+      dx: lean,
+      eyes: "happy",
+      legs: b % 2 ? [1, 0, 1] : [0, 1, 0],
+      y0: b % 2 ? 4 : 5,
+      extras: e
+    };
+  },
+  hatmishap: t => {
+    const c = t % 32;
+    const e = [];
+    const drop = c >= 10 && c < 20 ? 2 : c >= 20 && c < 22 ? 1 : 0;
+    const ox = c >= 10 && c < 20 ? 1 : 0;
+    const hy = drop;
+    const hat = (x, y, col) => e.push([x + ox, y + hy, col]);
+    hat(7, 0, "p");
+    hat(8, 0, "p");
+    for (let x = 6; x <= 9; x++) hat(x, 1, "p");
+    for (let x = 5; x <= 10; x++) hat(x, 2, "p");
+    for (let x = 3; x <= 12; x++) hat(x, 3, "p");
+    hat(8, 1, "a");
+    hat(6, 2, "a");
+    hat(10, 3, "a");
+    if (drop === 2) for (let x = 4; x <= 11; x++) hat(x, 4, "p");
+    if (c >= 14 && c < 22) {
+      e.push([13, 5, "g"], [14, 4, "g"], [14, 3, "g"]);
+      if (c % 2) e.push([15, 1, "a"], [14, 0, "l"]);
+    }
+    return {
+      ...BASE,
+      lamp: null,
+      eyes: drop === 2 ? "closed" : c >= 22 && c < 24 ? "happy" : "open",
+      ex: c < 10 ? 1 : 0,
+      legs: c < 8 ? walk(t) : [0, 0, 0],
+      dx: c < 8 ? c < 4 ? c - 2 : 5 - c : 0,
+      extras: e
+    };
+  },
+  lowbattery: t => {
+    const e = [];
+    rect(12, 1, 15, 1, "r", e);
+    rect(12, 6, 15, 6, "r", e);
+    e.push([12, 2, "r"], [12, 3, "r"], [12, 4, "r"], [12, 5, "r"], [15, 2, "r"], [15, 3, "r"], [15, 4, "r"], [15, 5, "r"], [13, 0, "r"], [14, 0, "r"]);
+    if (t % 6 < 3) rect(13, 5, 14, 5, "r", e);
+    const open = t % 24 >= 18 && t % 24 < 21;
+    return {
+      ...BASE,
+      y0: 6,
+      h: 6,
+      x0: 2,
+      w: 12,
+      lamp: "A",
+      eyes: open ? "open" : "closed",
+      ey: open ? 1 : 0,
+      legs: null,
+      extras: e
+    };
+  },
+  wake: t => {
+    const c = t % 30;
+    if (c < 8) return {
+      ...BASE,
+      x0: 2,
+      w: 12,
+      y0: 7,
+      h: 5,
+      lamp: "A",
+      eyes: c >= 6 ? "big" : "closed",
+      ey: 0,
+      legs: null
+    };
+    if (c < 10) return {
+      ...BASE,
+      x0: 4,
+      w: 8,
+      y0: 0,
+      h: 9,
+      lamp: null,
+      eyes: "big",
+      ey: 1,
+      legs: [1, 1, 1]
+    };
+    if (c < 12) return {
+      ...BASE,
+      y0: 2,
+      eyes: "big",
+      lamp: "a",
+      legs: [1, 1, 1]
+    };
+    if (c < 14) return {
+      ...BASE,
+      x0: 2,
+      w: 12,
+      y0: 5,
+      h: 6,
+      eyes: "open",
+      lamp: "a"
+    };
+    return {
+      ...BASE,
+      eyes: c === 20 || c === 21 ? "closed" : "open",
+      legs: [0, 0, 0]
+    };
+  },
+  builder: t => {
+    const s = [0, 1, 0, -1][Math.floor(t / 2) % 4];
+    const e = [];
+    rect(5, 2, 10, 3, "n", e);
+    e.push([5, 3, "m"], [10, 3, "m"]);
+    rect(4 + s, 0, 9 + s, 1, "p", e);
+    e.push([4 + s, 1, "1"]);
+    if (Math.floor(t / 2) % 4 === 3 && t % 2) e.push([1, 5, "l"], [0, 4, "l"]);
+    const arms = s ? [[1, 5, "g"], [14, 7, "g"]] : [[1, 6, "g"], [14, 6, "g"]];
+    return {
+      ...BASE,
+      lamp: null,
+      ex: s,
+      ey: -1,
+      legs: walk(t),
+      extras: [...e, ...arms]
+    };
+  },
+  mini: t => {
+    const c = t % 32;
+    const ex = c < 8 ? 0 : c < 16 ? -1 : c < 24 ? 1 : 0;
+    const ey = c >= 24 && c < 28 ? -1 : 0;
+    return {
+      ...BASE,
+      x0: 4,
+      w: 8,
+      y0: 6 + Math.floor(t / 4) % 2,
+      h: 5,
+      lamp: "a",
+      eyes: "big",
+      ex,
+      ey,
+      legs: [Math.floor(t / 2) % 2, 0, (Math.floor(t / 2) + 1) % 2],
+      extras: [[2, 8 + t % 2, "g"], [13, 8 + (t + 1) % 2, "g"]]
+    };
+  },
+  minityping: t => {
+    const e = [[2, 8 + t % 2, "g"], [13, 8 + (t + 1) % 2, "g"]];
+    const dy = t % 6;
+    e.push([7 + t % 3, 5 - dy, "p"]);
+    return {
+      ...BASE,
+      x0: 4,
+      w: 8,
+      y0: 7 - t % 2,
+      h: 5,
+      lamp: null,
+      legs: [0, 0, 0],
+      extras: e
+    };
+  },
+  happydance: t => {
+    const c = t % 4;
+    const e = [[1, 5 + [0, 1, 2, 1][c], "g"], [14, 5 + [2, 1, 0, 1][c], "g"]];
+    return {
+      ...BASE,
+      eyes: c % 2 ? "happy" : "open",
+      legs: c % 2 ? [1, 0, 1] : [0, 1, 0],
+      extras: e
+    };
+  },
+  jumping: t => {
+    const c = t % 8;
+    const y = [0, 1, -1, -3, -4, -2, 0, 0][c];
+    const armY = [6, 7, 6, 4, 3, 4, 6, 6][c];
+    return {
+      ...BASE,
+      y0: 4 + y,
+      eyes: c === 1 ? "closed" : "open",
+      legs: c >= 2 && c <= 5 ? [1, 1, 1] : [0, 0, 0],
+      extras: [[1, armY + y, "g"], [14, armY + y, "g"]]
+    };
+  },
+  // ── Loading & progress ──────────────────────────────────────────────────
+  loading: t => {
+    // Three dots chase around a ring at the top right; eyes follow the head.
+    const e = [];
+    const n = RING.length;
+    const head = t % n;
+    e.push(pt(RING[head], "l"), pt(RING[(head + n - 1) % n], "n"), pt(RING[(head + n - 2) % n], "m"));
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      extras: e
+    };
+  },
+  progress: t => {
+    // A bar fills across the top, two ticks per pixel; a hop when it lands.
+    const c = t % 32;
+    const fill = Math.min(12, Math.floor(c / 2));
+    const done = c >= 24;
+    const e = [];
+    // Lamp colours — a dim track that lights up — so the keyline wraps the whole bar.
+    rect(2, 0, 13, 1, "A", e);
+    if (fill > 0) rect(2, 0, 1 + fill, 1, "a", e);
+    const hop = done && (c === 25 || c === 26) ? 1 : 0;
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      eyes: done ? "happy" : "open",
+      ex: done ? 0 : fill < 4 ? -1 : fill < 9 ? 0 : 1,
+      ey: done ? 0 : -1,
+      lamp: done && c % 2 ? "A" : "a",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  hourglass: t => {
+    // Sand runs top to bottom, then the glass lifts and flips.
+    const c = t % 20;
+    const lift = c >= 16 ? -1 : 0;
+    const e = [];
+    const y = 3 + lift;
+    rect(13, y, 15, y, "n", e);
+    rect(13, y + 4, 15, y + 4, "n", e);
+    e.push([13, y + 1, "n"], [15, y + 1, "n"], [14, y + 2, "n"], [13, y + 3, "n"], [15, y + 3, "n"]);
+    const topFull = c < 8 || c >= 16;
+    e.push([14, y + 1, topFull ? "a" : "1"], [14, y + 3, topFull ? "1" : "a"]);
+    if (c >= 4 && c < 12 && c % 2) e.push([14, y + 2, "a"]);
+    e.push([13, 8 + lift, "g"]);
+    return {
+      ...BASE,
+      ex: 1,
+      eyes: c === 17 ? "closed" : "open",
+      extras: e
+    };
+  },
+  waiting: t => {
+    // Foot taps, checks the wristwatch, dots pile up.
+    const c = t % 16;
+    const e = [];
+    // Wall clock, top left: a ring with one hand ticking round the face.
+    e.push([1, 0, "n"], [2, 0, "n"], [0, 1, "n"], [3, 1, "n"], [0, 2, "n"], [3, 2, "n"], [1, 3, "n"], [2, 3, "n"]);
+    rect(1, 1, 2, 2, "l", e);
+    e.push(pt([[2, 1], [2, 2], [1, 2], [1, 1]][Math.floor(c / 2) % 4], "k"));
+    const dots = Math.min(3, Math.floor(c / 4));
+    for (let i = 0; i < dots; i++) e.push([13 + i, 1, "n"]);
+    const look = c >= 6 && c < 11;
+    return {
+      ...BASE,
+      ex: look ? -1 : 0,
+      ey: look ? -1 : 0,
+      legs: [0, 0, c % 2],
+      extras: e
+    };
+  },
+  syncing: t => {
+    // Two arcs chase each other around the ring; the lamp pulses in step.
+    const e = [];
+    const n = RING.length;
+    const p = t % n;
+    for (const off of [0, 1, 2]) {
+      e.push(pt(RING[(p + off) % n], off === 2 ? "l" : "n"));
+      e.push(pt(RING[(p + off + 5) % n], off === 2 ? "l" : "n"));
+    }
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      lamp: t % 4 < 2 ? "a" : "A",
+      extras: e
+    };
+  },
+  downloading: t => {
+    // An arrow drops into a tray; the parcel lands, then the tray clears.
+    const c = t % 12;
+    const e = [[13, 5, "n"], [15, 5, "n"], [13, 6, "n"], [14, 6, "n"], [15, 6, "n"]];
+    if (c < 6) {
+      const y = Math.floor(c / 2);
+      arrowDown(14, y, "l", e);
+    } else if (c === 6) {
+      rect(13, 6, 15, 6, "l", e);
+    } else if (c < 10) {
+      e.push([14, 5, "a"]);
+    }
+    return {
+      ...BASE,
+      ex: 1,
+      ey: c < 2 ? -1 : c < 6 ? 0 : 1,
+      extras: e
+    };
+  },
+  uploading: t => {
+    // The parcel lifts off the tray and climbs out of frame.
+    const c = t % 12;
+    const e = [[13, 5, "n"], [15, 5, "n"], [13, 6, "n"], [14, 6, "n"], [15, 6, "n"]];
+    if (c < 2) e.push([14, 5, "a"]);else if (c < 10) arrowUp(14, 2 - Math.floor((c - 2) / 2), "l", e);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: c < 4 ? 1 : c < 8 ? 0 : -1,
+      extras: e
+    };
+  },
+  connecting: t => {
+    // Signal bars fill one at a time, then all four blink: connected.
+    const c = t % 14;
+    const bars = c < 8 ? Math.floor(c / 2) : c % 2 ? 4 : 0;
+    const e = [];
+    for (let i = 0; i < 4; i++) {
+      const x = 12 + i;
+      const lit = i < bars;
+      for (let y = 4 - i; y <= 4; y++) e.push([x, y, lit ? "g" : "1"]);
+    }
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c >= 8 ? "happy" : "open",
+      extras: e
+    };
+  },
+  scanning: t => {
+    // A bright line sweeps down the body with a faint trail.
+    const c = t % 14;
+    const e = [];
+    if (c < 9) {
+      const y = 4 + c;
+      if (c > 0) rect(1, y - 1, 14, y - 1, "n", e);
+      rect(1, y, 14, y, "l", e);
+    }
+    return {
+      ...BASE,
+      eyes: "big",
+      legs: [0, 0, 0],
+      extras: e
+    };
+  },
+  searching: t => {
+    // Binoculars up, slow sweep left and right.
+    const e = [];
+    for (const x of [4, 9]) {
+      rect(x, 5, x + 2, 5, "n", e);
+      rect(x, 7, x + 2, 7, "n", e);
+      e.push([x, 6, "n"], [x + 2, 6, "n"], [x + 1, 6, "k"]);
+    }
+    e.push([7, 6, "n"], [8, 6, "n"]);
+    const s = Math.floor(t / 3) % 4;
+    const dx = [-1, 0, 1, 0][s];
+    return {
+      ...BASE,
+      dx,
+      legs: s % 2 ? walk(t) : [0, 0, 0],
+      extras: e
+    };
+  },
+  // ── Empty & nothing ─────────────────────────────────────────────────────
+  empty: t => {
+    // Peers into an open box, finds nothing, looks back at you.
+    const c = t % 16;
+    const e = [];
+    rect(13, 7, 13, 10, "n", e);
+    rect(15, 7, 15, 10, "n", e);
+    rect(14, 10, 14, 10, "n", e);
+    rect(14, 8, 14, 9, "1", e);
+    const dots = c >= 9 ? Math.min(3, c - 8) : 0;
+    for (let i = 0; i < dots; i++) e.push([12 + i, 1, "n"]);
+    const peer = c < 8;
+    return {
+      ...BASE,
+      ex: peer ? 1 : 0,
+      ey: peer ? 1 : 0,
+      eyes: c === 8 ? "closed" : "open",
+      extras: e
+    };
+  },
+  shrug: t => {
+    // Arms up, looks left, looks right, arms down.
+    const c = t % 16;
+    const up = c >= 4 && c < 12;
+    const e = up ? [[2, 5, "g"], [1, 4, "g"], [13, 5, "g"], [14, 4, "g"]] : [];
+    return {
+      ...BASE,
+      ex: c < 4 ? 0 : c < 8 ? -1 : c < 12 ? 1 : 0,
+      ey: up ? -1 : 0,
+      extras: e
+    };
+  },
+  fishing: t => {
+    // Rod out, bobber bobbing; one tug, one splash, back to waiting.
+    const c = t % 32;
+    const e = [[13, 6, "g"], [14, 6, "g"], [14, 5, "m"], [15, 4, "m"]];
+    const tug = c >= 20 && c < 24;
+    const pop = c >= 24 && c < 27;
+    const by = tug ? 14 : pop ? 11 : 12 + Math.floor(c / 4) % 2;
+    rect(15, 5, 15, by - 1, "n", e);
+    e.push([15, by, "r"], [15, by + 1, "l"]);
+    if (pop) e.push([14, 12, "l"], [13, 13, "l"]);
+    return {
+      ...BASE,
+      ex: 1,
+      eyes: tug ? "big" : c === 15 ? "closed" : "open",
+      extras: e
+    };
+  },
+  listening: t => {
+    // Shifted left; a hand cupped at the side, sound arcs arriving from the right.
+    const c = Math.floor(t / 2) % 4;
+    const e = [[13, 5, "g"], [14, 5, "g"], [14, 6, "g"]];
+    const inner = [[15, 4, "n"], [16, 5, "n"], [16, 6, "n"], [15, 7, "n"]];
+    const outer = [[16, 3, "l"], [17, 4, "l"], [17, 5, "l"], [17, 6, "l"], [17, 7, "l"], [16, 8, "l"]];
+    if (c === 0 || c === 1) e.push(...inner);
+    if (c === 1 || c === 2) e.push(...outer);
+    return {
+      ...BASE,
+      dx: -2,
+      eyes: "closed",
+      extras: e
+    };
+  },
+  tumbleweed: t => {
+    // A tumbleweed rolls past in the foreground; eyes follow it off the edge.
+    const c = t % 28;
+    const e = [];
+    const wx = 15 - c;
+    if (c < 20) {
+      if (c % 2) e.push([wx, 11, "A"], [wx + 2, 11, "A"], [wx + 1, 12, "A"], [wx, 13, "A"], [wx + 2, 13, "A"]);else e.push([wx + 1, 11, "A"], [wx, 12, "A"], [wx + 2, 12, "A"], [wx + 1, 13, "A"]);
+    }
+    const ex = c >= 20 ? 0 : wx > 8 ? 1 : wx > 3 ? 0 : -1;
+    return {
+      ...BASE,
+      ex,
+      ey: c < 20 ? 1 : 0,
+      extras: e
+    };
+  },
+  // ── Errors & trouble ────────────────────────────────────────────────────
+  warning: t => {
+    // Shifted left; a warning sign held up on the right, lamp blinking.
+    const e = [];
+    e.push([15, 0, "a"]);
+    rect(14, 1, 16, 2, "a", e);
+    rect(13, 3, 17, 4, "a", e);
+    e.push([15, 1, "k"], [15, 2, "k"], [15, 4, "k"]);
+    e.push([13, 5, "g"], [14, 5, "g"]);
+    return {
+      ...BASE,
+      dx: -2,
+      eyes: "big",
+      ex: 1,
+      ey: -1,
+      lamp: t % 4 < 2 ? "a" : "A",
+      extras: e
+    };
+  },
+  crash: t => {
+    // Burst, smoke, then dazed.
+    const c = t % 20;
+    const e = [];
+    if (c < 3) {
+      const rays = c % 2 ? [[1, 2], [14, 2], [0, 7], [15, 7], [4, 0], [11, 0], [1, 11], [14, 11]] : [[2, 1], [13, 1], [0, 5], [15, 5], [6, 0], [9, 0], [0, 9], [15, 9]];
+      rays.forEach(r => e.push(pt(r, c === 0 ? "l" : "a")));
+    } else if (c < 10) {
+      const y = 2 - Math.floor((c - 3) / 2);
+      if (y >= 0) e.push([2, y, "n"], [13, y, "n"], [1, y + 1, "n"], [14, y + 1, "n"]);
+    }
+    return {
+      ...BASE,
+      eyes: "x",
+      lamp: c < 3 ? "r" : "R",
+      dx: c < 3 ? [0, 1, -1][c] : c >= 10 ? [0, 1, 0, -1][c % 4] : 0,
+      legs: c < 10 ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  panic: t => {
+    // Arms flail, sweat flies, lamp strobes.
+    const u = t % 2;
+    const e = u ? [[2, 5, "g"], [1, 4, "g"], [13, 5, "g"], [14, 4, "g"], [14, 2, "l"]] : [[2, 7, "g"], [1, 8, "g"], [13, 7, "g"], [14, 8, "g"], [1, 3, "l"]];
+    return {
+      ...BASE,
+      eyes: "big",
+      lamp: u ? "r" : "a",
+      dx: [0, 1, 0, -1][t % 4],
+      legs: walk(t),
+      extras: e
+    };
+  },
+  sos: t => {
+    // The lamp flashes S-O-S in morse; arms wave between letters.
+    const c = t % SOS.length;
+    const on = SOS[c] === 1;
+    const u = Math.floor(t / 2) % 2;
+    const e = [[1, 4 + u * 2, "g"], [2, 5 + u * 2, "g"], [13, 5 + u * 2, "g"], [14, 4 + u * 2, "g"]];
+    return {
+      ...BASE,
+      eyes: "big",
+      lamp: on ? "r" : "R",
+      extras: e
+    };
+  },
+  offline: t => {
+    // A struck-through cloud; slumped, lamp dim, one glance up.
+    const c = t % 16;
+    const e = [];
+    rect(11, 0, 14, 0, "n", e);
+    rect(10, 1, 15, 1, "n", e);
+    rect(11, 2, 14, 2, "n", e);
+    if (c % 4 < 2) e.push([10, 3, "r"], [11, 2, "r"], [12, 1, "r"], [13, 0, "r"]);
+    const glance = c >= 10 && c < 14;
+    return {
+      ...BASE,
+      y0: 5,
+      lamp: "A",
+      eyes: glance ? "open" : "closed",
+      ex: 1,
+      ey: glance ? -1 : 0,
+      extras: e
+    };
+  },
+  timeout: t => {
+    // A clock ticks round, then turns red; Otto shakes.
+    const c = t % 16;
+    const late = c >= 12;
+    const e = [];
+    const ring = late ? "r" : "n";
+    e.push([13, 1, ring], [14, 1, ring], [12, 2, ring], [15, 2, ring], [12, 3, ring], [15, 3, ring], [13, 4, ring], [14, 4, ring]);
+    rect(13, 2, 14, 3, "l", e);
+    e.push(pt([[14, 2], [14, 3], [13, 3], [13, 2]][late ? 0 : Math.floor(c / 3) % 4], "k"));
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: late ? "closed" : "open",
+      lamp: late && c % 2 ? "r" : "a",
+      dx: late ? [0, 1, 0, -1][c % 4] : 0,
+      extras: e
+    };
+  },
+  locked: t => {
+    // A padlock on the right: look, strain at it, give up with a shrug.
+    const c = t % 20;
+    const e = [];
+    padlock(false, e);
+    const strain = c >= 6 && c < 12;
+    const give = c >= 12;
+    if (strain) e.push([13, 7, "g"], [14, 7, "g"]);
+    if (give) e.push([2, 5, "g"], [1, 4, "g"]);
+    return {
+      ...BASE,
+      ex: give ? 0 : 1,
+      ey: give ? 0 : -1,
+      eyes: strain ? "closed" : "open",
+      dx: strain && c % 2 ? -1 : 0,
+      extras: e
+    };
+  },
+  unlocked: t => {
+    // The shackle pops open; sparkles, a hop, a happy Otto.
+    const c = t % 20;
+    const open = c >= 4;
+    const e = [];
+    padlock(open, e);
+    if (c >= 4 && c < 10) {
+      const sp = c % 2 ? [[11, 0], [15, 5], [12, 6]] : [[12, 0], [11, 4], [15, 6]];
+      sp.forEach(s => e.push(pt(s, "l")));
+    }
+    const hop = c === 5 || c === 6 ? 1 : 0;
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      ex: open ? 0 : 1,
+      ey: open ? 0 : -1,
+      eyes: open ? "happy" : "open",
+      lamp: open && c % 2 ? "A" : "a",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  denied: t => {
+    // Shifted left; a red no-entry sign, head shaking.
+    const e = [];
+    rect(13, 0, 15, 0, "r", e);
+    rect(13, 4, 15, 4, "r", e);
+    for (let y = 1; y <= 3; y++) e.push([12, y, "r"], [16, y, "r"]);
+    e.push([13, 3, "r"], [14, 2, "r"], [15, 1, "r"]);
+    return {
+      ...BASE,
+      dx: -1,
+      ex: [-1, 0, 1, 0][Math.floor(t / 2) % 4],
+      ey: -1,
+      extras: e
+    };
+  },
+  broken: t => {
+    // A crack down the middle; a band-aid goes on.
+    const c = t % 24;
+    const e = [[8, 4, "k"], [7, 5, "k"], [8, 6, "k"], [7, 7, "k"], [8, 8, "k"], [7, 9, "k"], [8, 10, "k"]];
+    if (c >= 8) {
+      rect(6, 8, 9, 9, "n", e);
+      rect(7, 8, 8, 9, "l", e);
+    }
+    return {
+      ...BASE,
+      eyes: c < 8 ? "closed" : c === 20 ? "closed" : "open",
+      lamp: c < 8 && c % 2 ? "A" : "a",
+      dx: c < 4 ? [0, 1, 0, -1][c] : 0,
+      extras: e
+    };
+  },
+  sad: t => {
+    // Sunk a row, lamp dim, a tear rolls down and drops in.
+    const c = t % 16;
+    const ty = c >= 2 && c < 10 ? 8 + Math.floor((c - 2) / 2) : c >= 10 && c < 12 ? 12 : -1;
+    const e = ty >= 0 ? [[5, ty, "l"]] : [];
+    return {
+      ...BASE,
+      y0: 5,
+      lamp: "A",
+      eyes: "closed",
+      extras: e
+    };
+  },
+  rain: t => {
+    // A rain cloud overhead, drops falling; lamp dim, eyes shut.
+    const c = t % 12;
+    const e = [];
+    rect(5, 0, 10, 0, "n", e);
+    rect(4, 1, 11, 1, "m", e);
+    [1, 4, 8, 11, 14].forEach((x, i) => {
+      const y = 2 + (c + i * 3) % 11;
+      e.push([x, y, "l"]);
+    });
+    return {
+      ...BASE,
+      y0: 5,
+      lamp: "A",
+      eyes: "closed",
+      extras: e
+    };
+  },
+  sick: t => {
+    // A thermometer climbs; wobbling, sweating, eyes shut.
+    const c = t % 12;
+    const e = [];
+    rect(14, 2, 14, 7, "l", e);
+    e.push([14, 8, "r"], [15, 3, "n"], [15, 5, "n"]);
+    const level = Math.min(4, Math.floor(c / 2));
+    if (level > 0) rect(14, 8 - level, 14, 7, "r", e);
+    e.push(c % 2 ? [2, 4, "l"] : [1, 5, "l"]);
+    return {
+      ...BASE,
+      eyes: "closed",
+      lamp: "A",
+      dx: [0, 1, 0, -1][Math.floor(c / 3) % 4],
+      extras: e
+    };
+  },
+  flood: t => {
+    // In over the eyes, arms flailing, bubbles rising, lamp strobing.
+    const c = t % 8;
+    const e = [[1, 7 + c % 2, "g"], [2, 8 + c % 2, "g"], [13, 8 - c % 2, "g"], [14, 7 - c % 2, "g"], [0, 11 - c % 4, "l"], [15, 12 - (c + 2) % 4, "l"]];
+    return {
+      ...BASE,
+      submerged: true,
+      y0: 9,
+      eyes: "big",
+      lamp: c % 2 ? "a" : "A",
+      legs: null,
+      extras: e
+    };
+  },
+  bug: t => {
+    // A beetle crawls across the body; eyes track it; it flies off.
+    const c = t % 24;
+    const e = [];
+    let ex = 0;
+    let ey = 1;
+    if (c < 20) {
+      const bx = 3 + Math.floor(c / 2);
+      rect(bx, 8, bx + 1, 9, "1", e);
+      e.push([bx - 1, 9 - c % 2, "k"], [bx + 2, 8 + c % 2, "k"]);
+      ex = bx < 6 ? -1 : bx > 9 ? 1 : 0;
+    } else {
+      const f = c - 20;
+      e.push([12 + f, 7 - f, "1"], [13 + f, 7 - f, "1"], [12 + f, 6 - f, "n"], [14 + f, 6 - f, "n"]);
+      ex = 1;
+      ey = -1;
+    }
+    return {
+      ...BASE,
+      ex,
+      ey,
+      eyes: c >= 18 ? "big" : "open",
+      extras: e
+    };
+  },
+  alarm: t => {
+    // The lamp becomes a siren: red strobe, light rays sweeping.
+    const u = t % 2;
+    const e = u ? [[4, 2, "l"], [11, 2, "l"], [6, 0, "l"], [9, 0, "l"]] : [[3, 1, "l"], [12, 1, "l"], [7, 0, "l"], [8, 0, "l"]];
+    return {
+      ...BASE,
+      eyes: "big",
+      lamp: u ? "r" : "R",
+      extras: e
+    };
+  },
+  frozen: t => {
+    // Iced over: icicles for legs, snow falling, shivering.
+    const c = t % 12;
+    const e = [[4, 11, "l"], [4, 12, "l"], [7, 11, "l"], [10, 11, "l"], [10, 12, "l"], [3, 3, "l"], [12, 3, "l"]];
+    [1, 14, 5, 10].forEach((x, i) => e.push([x, (c * 2 + i * 3) % 12, "l"]));
+    return {
+      ...BASE,
+      lamp: "A",
+      legs: null,
+      dx: t % 2,
+      extras: e
+    };
+  },
+  snail: t => {
+    // A snail crosses the foreground at one pixel per six ticks.
+    const c = t % 36;
+    const e = [];
+    const sx = Math.floor(c / 6) - 3;
+    rect(sx, 9, sx + 2, 11, "A", e);
+    e.push([sx + 1, 10, "a"], [sx + 3, 11, "n"], [sx + 4, 11, "n"], [sx + 4, 10, "n"], [sx + 4, 9, "k"]);
+    return {
+      ...BASE,
+      ex: -1,
+      ey: 1,
+      eyes: c % 12 === 11 ? "closed" : "open",
+      extras: e
+    };
+  },
+  angry: t => {
+    // Brows down, lamp red, steam off the top, stomping.
+    const e = [[4, 5, "k"], [5, 5, "k"], [6, 6, "k"], [9, 6, "k"], [10, 5, "k"], [11, 5, "k"]];
+    if (t % 2) e.push([4, 1, "n"], [11, 1, "n"]);else e.push([3, 0, "n"], [12, 0, "n"]);
+    return {
+      ...BASE,
+      ey: 1,
+      lamp: t % 4 < 2 ? "r" : "R",
+      legs: walk(t),
+      extras: e
+    };
+  },
+  ghost: t => {
+    // Grey, translucent, no legs, floating; white eyes.
+    const c = t % 8;
+    const e = [];
+    const y0 = 4 - (c < 4 ? 0 : 1);
+    rect(4, y0, 11, y0 + 6, "m", e);
+    rect(3, y0 + 1, 3, y0 + 5, "m", e);
+    rect(12, y0 + 1, 12, y0 + 5, "m", e);
+    [4, 7, 10].forEach(x => e.push([x, y0 + 7, "m"]));
+    rect(5, y0 + 2, 6, y0 + 3, "l", e);
+    rect(9, y0 + 2, 10, y0 + 3, "l", e);
+    return {
+      ...BASE,
+      y0,
+      lamp: "A",
+      legs: null,
+      extras: e
+    };
+  },
+  nervous: t => {
+    // Eyes darting, sweat, feet fidgeting, lamp flickering.
+    const e = [t % 2 ? [13, 3, "l"] : [2, 3, "l"]];
+    return {
+      ...BASE,
+      ex: t % 2 ? 1 : -1,
+      lamp: t % 3 ? "a" : "A",
+      legs: t % 2 ? [1, 0, 0] : [0, 0, 1],
+      extras: e
+    };
+  },
+  // ── Questions & investigation ───────────────────────────────────────────
+  puzzled: t => {
+    // A tentacle curls up to scratch the head; eyes wander.
+    const c = t % 16;
+    const scratch = c >= 4 && c < 12;
+    const e = scratch ? [[13, 6, "g"], [14, 5, "g"], [14, 4, "g"], [13, 3 - c % 2, "g"]] : [];
+    return {
+      ...BASE,
+      ex: c < 4 ? 0 : c < 8 ? -1 : c < 12 ? 1 : 0,
+      ey: scratch ? -1 : 0,
+      eyes: c === 14 ? "closed" : "open",
+      extras: e
+    };
+  },
+  detective: t => {
+    // Deerstalker hat, magnifying glass held out and moving; eyes track it.
+    const c = t % 16;
+    const e = [];
+    rect(3, 3, 12, 3, "A", e);
+    rect(5, 1, 10, 2, "A", e);
+    rect(5, 2, 10, 2, "a", e);
+    const gy = Math.floor(c / 4) % 2 ? 4 : 5;
+    e.push([0, gy, "n"], [1, gy, "n"], [2, gy, "n"], [0, gy + 1, "n"], [2, gy + 1, "n"], [0, gy + 2, "n"], [1, gy + 2, "n"], [2, gy + 2, "n"]);
+    e.push([1, gy + 1, "l"], [2, gy + 3, "g"], [1, gy + 3, "g"]);
+    return {
+      ...BASE,
+      lamp: null,
+      ex: -1,
+      ey: gy === 4 ? -1 : 0,
+      eyes: c === 15 ? "closed" : "open",
+      extras: e
+    };
+  },
+  reading: t => {
+    // An open book held up; eyes run along the lines; a page turns.
+    const c = t % 24;
+    const e = [];
+    rect(3, 8, 12, 11, "l", e);
+    rect(7, 8, 8, 11, "n", e);
+    const flip = c >= 20 && c < 22;
+    if (flip) rect(9, 8, 12, 11, "n", e);
+    for (const y of [9, 10]) {
+      rect(4, y, 6, y, "k", e);
+      if (!flip) rect(9, y, 11, y, "k", e);
+    }
+    e.push([2, 9, "g"], [13, 9, "g"]);
+    return {
+      ...BASE,
+      ey: 1,
+      ex: c < 20 ? [-1, 0, 1][Math.floor(c / 2) % 3] : 0,
+      eyes: c === 22 ? "closed" : "open",
+      legs: null,
+      extras: e
+    };
+  },
+  // ── Success & celebration ───────────────────────────────────────────────
+  success: t => {
+    // A check mark lands on the right; sparkles, a hop, the lamp blinks.
+    const c = t % 16;
+    const e = [];
+    if (c >= 2) e.push([11, 2, "g"], [12, 3, "g"], [13, 2, "g"], [14, 1, "g"], [15, 0, "g"]);
+    if (c >= 3 && c < 7) {
+      const sp = c % 2 ? [[10, 0], [15, 3], [13, 5]] : [[11, 0], [14, 4], [9, 1]];
+      sp.forEach(s => e.push(pt(s, "l")));
+    }
+    const hop = c === 3 || c === 4 ? 1 : 0;
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      eyes: c >= 2 ? "happy" : "open",
+      ex: c >= 2 ? 0 : 1,
+      ey: c >= 2 ? 0 : -1,
+      lamp: c >= 2 && c < 8 && c % 2 ? "A" : "a",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  celebrate: t => {
+    // Confetti falls, arms up, bouncing.
+    const c = t % 12;
+    const e = [];
+    const cols = [0, 15, 2, 13, 5, 10, 1, 14];
+    const tint = ["p", "l", "a", "p", "l", "p", "a", "l"];
+    cols.forEach((x, i) => e.push([x, (c * 2 + i * 5) % 13, tint[i]]));
+    const up = c % 4 < 2;
+    e.push([2, 5, "g"], [1, 4, "g"], [13, 5, "g"], [14, 4, "g"]);
+    return {
+      ...BASE,
+      y0: up ? 3 : 4,
+      eyes: "happy",
+      legs: up ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  thumbsup: t => {
+    // A fist rises with the thumb out; then a wink.
+    const c = t % 12;
+    const lift = c < 4 ? 2 : 0;
+    const e = [];
+    rect(13, 6 + lift, 14, 7 + lift, "g", e);
+    e.push([14, 4 + lift, "g"], [14, 5 + lift, "g"]);
+    const wink = c >= 6 && c < 10;
+    if (wink) e.push([5, 6, "g"], [6, 6, "g"]);
+    return {
+      ...BASE,
+      eyes: c >= 4 && !wink ? "happy" : "open",
+      extras: e
+    };
+  },
+  party: t => {
+    // Party hat in place of the lamp, confetti, a side-to-side dance.
+    const c = t % 16;
+    const e = [];
+    e.push([7, 0, "a"], [8, 0, "a"]);
+    rect(6, 1, 9, 1, "p", e);
+    rect(5, 2, 10, 2, "a", e);
+    rect(4, 3, 11, 3, "p", e);
+    [0, 15, 2, 13].forEach((x, i) => e.push([x, (c * 2 + i * 4) % 12, i % 2 ? "l" : "p"]));
+    const u = Math.floor(c / 2) % 2;
+    e.push([1, 5 + u, "g"], [2, 6 - u, "g"], [13, 6 - u, "g"], [14, 5 + u, "g"]);
+    return {
+      ...BASE,
+      lamp: null,
+      eyes: "happy",
+      dx: [0, 1, 0, -1][Math.floor(c / 2) % 4],
+      legs: walk(Math.floor(c / 2)),
+      extras: e
+    };
+  },
+  trophy: t => {
+    // A cup held overhead, arms raised, sparkles, a hop every so often.
+    const c = t % 16;
+    const e = [];
+    rect(5, 0, 10, 0, "a", e);
+    rect(6, 1, 9, 1, "a", e);
+    rect(7, 2, 8, 2, "A", e);
+    rect(6, 3, 9, 3, "A", e);
+    e.push([2, 5, "g"], [1, 4, "g"], [13, 5, "g"], [14, 4, "g"]);
+    if (c % 2) e.push([3, 0, "l"], [12, 1, "l"]);else e.push([4, 1, "l"], [11, 0, "l"]);
+    const hop = c === 8 || c === 9 ? 1 : 0;
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      lamp: null,
+      eyes: "happy",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  starred: t => {
+    // A star pops in at the top right and twinkles.
+    const c = t % 12;
+    const e = [];
+    if (c >= 1) {
+      e.push([13, 0, "a"]);
+      rect(11, 1, 15, 1, "a", e);
+      rect(12, 2, 14, 2, "a", e);
+      e.push([12, 3, "a"], [14, 3, "a"], [11, 4, "a"], [15, 4, "a"]);
+      if (c % 3 === 0) e.push([13, 2, "l"]);
+    }
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c >= 4 ? "happy" : "open",
+      extras: e
+    };
+  },
+  love: t => {
+    // Hearts float up either side; the body bobs.
+    const c = t % 16;
+    const e = [];
+    const heart = (x, y) => {
+      if (y < -2) return;
+      e.push([x, y, "r"], [x + 2, y, "r"], [x, y + 1, "r"], [x + 1, y + 1, "r"], [x + 2, y + 1, "r"], [x + 1, y + 2, "r"]);
+    };
+    heart(0, 8 - Math.floor(c / 2) * 2);
+    heart(13, 8 - Math.floor((c + 8) % 16 / 2) * 2);
+    return {
+      ...BASE,
+      y0: 4 + Math.floor(c / 4) % 2,
+      eyes: "happy",
+      extras: e
+    };
+  },
+  wave: t => {
+    // One arm up, hand swinging side to side; a smile at the end.
+    const c = t % 12;
+    const e = [[13, 5, "g"], [14, 4, "g"], [c % 2 ? 15 : 14, 3, "g"]];
+    return {
+      ...BASE,
+      eyes: c >= 8 ? "happy" : "open",
+      extras: e
+    };
+  },
+  bow: t => {
+    // A slow bow: squash forward, eyes shut, back up.
+    const c = t % 16;
+    const down = c >= 4 && c < 12;
+    return down ? {
+      ...BASE,
+      y0: 6,
+      h: 5,
+      eyes: "closed"
+    } : {
+      ...BASE
+    };
+  },
+  cool: t => {
+    // Sunglasses drop into place; a little sway.
+    const c = t % 16;
+    const y = Math.min(6, 3 + c);
+    const e = [];
+    rect(4, y, 6, y + 1, "k", e);
+    rect(9, y, 11, y + 1, "k", e);
+    e.push([7, y, "k"], [8, y, "k"]);
+    const on = y === 6;
+    return {
+      ...BASE,
+      dx: on ? [0, 0, 1, 0, 0, -1][Math.floor(c / 2) % 6] : 0,
+      extras: e
+    };
+  },
+  flexing: t => {
+    // Both arms up in a flex; the biceps pop every other beat.
+    const c = t % 8;
+    const e = [[2, 6, "g"], [1, 6, "g"], [1, 5, "g"], [1, 4, "g"], [13, 6, "g"], [14, 6, "g"], [14, 5, "g"], [14, 4, "g"]];
+    if (c < 4) e.push([0, 5, "g"], [15, 5, "g"]);
+    return {
+      ...BASE,
+      eyes: c < 4 ? "open" : "happy",
+      extras: e
+    };
+  },
+  zen: t => {
+    // Floating above the water, eyes shut, slow bob, a sparkle or two.
+    const c = t % 16;
+    const e = c < 8 ? [[1, 5, "l"], [14, 9, "l"]] : [[2, 10, "l"], [13, 4, "l"]];
+    return {
+      ...BASE,
+      y0: 3 + Math.floor(c / 8) % 2,
+      lamp: "a",
+      eyes: "closed",
+      legs: null,
+      extras: e
+    };
+  },
+  // ── Tool moments ────────────────────────────────────────────────────────
+  recording: t => {
+    // A red REC dot blinks at the top right; eyes slowly sweep the room.
+    const c = t % 16;
+    const e = c % 4 < 2 ? [...rect(13, 0, 14, 1, "r", [])] : [];
+    return {
+      ...BASE,
+      ex: [-1, -1, 0, 0, 1, 1, 0, 0][Math.floor(c / 2)],
+      extras: e
+    };
+  },
+  paused: t => {
+    // Pause bars overhead; resting with the lamp dim, one peek.
+    const c = t % 16;
+    const e = [];
+    rect(13, 0, 13, 3, "n", e);
+    rect(15, 0, 15, 3, "n", e);
+    const peek = c >= 8 && c < 10;
+    return {
+      ...BASE,
+      y0: 5,
+      lamp: "A",
+      eyes: peek ? "open" : "closed",
+      ex: 1,
+      ey: peek ? -1 : 0,
+      extras: e
+    };
+  },
+  filtering: t => {
+    // A funnel on the right: mixed bits go in the top, only orange comes out.
+    const c = t % 12;
+    const e = [];
+    rect(12, 0, 15, 0, "n", e);
+    e.push([12, 1, "n"], [15, 1, "n"], [13, 2, "n"], [14, 2, "n"], [14, 3, "n"], [14, 4, "n"]);
+    const mix = ["p", "l", "a", "l", "p", "a"];
+    e.push([13, 1, mix[c % 6]], [14, 1, mix[(c + 3) % 6]]);
+    e.push([14, 5 + c % 4, "a"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: c % 8 < 4 ? -1 : 1,
+      extras: e
+    };
+  },
+  pinned: t => {
+    // A pushpin drops in from above and lands with a blink.
+    const c = t % 12;
+    const dy = c < 3 ? c - 3 : 0;
+    const e = [];
+    rect(13, 1 + dy, 14, 2 + dy, "r", e);
+    e.push([13, 3 + dy, "n"], [14, 3 + dy, "n"], [13, 4 + dy, "n"], [13, 5 + dy, "n"]);
+    if (c === 4 || c === 5) e.push([15, 0, "l"], [12, 6, "l"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c === 3 ? "closed" : "open",
+      extras: e
+    };
+  },
+  rewind: t => {
+    // Moonwalks left while a clock runs backwards beside it.
+    const c = t % 16;
+    const e = [];
+    e.push([1, 0, "n"], [2, 0, "n"], [0, 1, "n"], [3, 1, "n"], [0, 2, "n"], [3, 2, "n"], [1, 3, "n"], [2, 3, "n"]);
+    rect(1, 1, 2, 2, "l", e);
+    e.push(pt([[1, 1], [1, 2], [2, 2], [2, 1]][c % 4], "k"));
+    return {
+      ...BASE,
+      dx: 3 - Math.floor(c / 2),
+      ex: 1,
+      legs: walk(t),
+      extras: e
+    };
+  },
+  storing: t => {
+    // Crates stack up on the right, one lowered into place every six ticks.
+    const c = t % 24;
+    const e = [];
+    const placed = Math.floor(c / 6);
+    for (let i = 0; i < Math.min(3, placed); i++) {
+      const y = 11 - i * 2;
+      rect(13, y, 14, y + 1, "A", e);
+      e.push([13, y, "a"]);
+    }
+    if (placed < 3) {
+      const y = 4 + (c % 6 < 3 ? 0 : 1);
+      rect(13, y, 14, y + 1, "A", e);
+      e.push([13, y, "a"], [13, y + 2, "g"], [14, y + 2, "g"]);
+    }
+    return {
+      ...BASE,
+      ex: 1,
+      ey: placed < 3 ? 0 : 1,
+      eyes: placed === 3 && c % 6 === 5 ? "happy" : "open",
+      extras: e
+    };
+  },
+  printing: t => {
+    // A little printer spools out a strip of log lines.
+    const c = t % 16;
+    const e = [];
+    rect(13, 3, 15, 5, "n", e);
+    e.push([14, 4, "1"]);
+    const len = Math.min(6, c);
+    if (len > 0) {
+      rect(13, 6, 15, 5 + len, "l", e);
+      for (let y = 6; y <= 5 + len; y += 2) e.push([14, y, "k"]);
+    }
+    return {
+      ...BASE,
+      ex: 1,
+      ey: 1,
+      extras: e
+    };
+  },
+  stopwatch: t => {
+    // A stopwatch with a fast hand; speed lines off the far side.
+    const e = [];
+    e.push([13, 0, "n"], [13, 1, "n"], [14, 1, "n"], [12, 2, "n"], [15, 2, "n"], [12, 3, "n"], [15, 3, "n"], [13, 4, "n"], [14, 4, "n"]);
+    rect(13, 2, 14, 3, "l", e);
+    e.push(pt([[14, 2], [14, 3], [13, 3], [13, 2]][t % 4], "k"));
+    if (t % 2) e.push([0, 6, "n"], [1, 6, "n"], [0, 9, "n"]);else e.push([0, 7, "n"], [1, 8, "n"], [0, 8, "n"]);
+    return {
+      ...BASE,
+      eyes: "big",
+      ex: 1,
+      ey: -1,
+      extras: e
+    };
+  },
+  spotlight: t => {
+    // The lamp throws a beam that sweeps left, up, right.
+    const c = t % 12;
+    const e = [];
+    if (c < 4) {
+      rect(4, 1, 7, 1, "a", e);
+      rect(2, 0, 6, 0, "a", e);
+    } else if (c < 8) {
+      rect(6, 1, 9, 1, "a", e);
+      rect(5, 0, 10, 0, "a", e);
+    } else {
+      rect(8, 1, 11, 1, "a", e);
+      rect(9, 0, 13, 0, "a", e);
+    }
+    return {
+      ...BASE,
+      ex: c < 4 ? -1 : c < 8 ? 0 : 1,
+      ey: -1,
+      extras: e
+    };
+  },
+  keys: t => {
+    // A keyring held out; the keys jingle.
+    const c = t % 8;
+    const e = [[13, 5, "g"], [14, 5, "g"]];
+    e.push([13, 6, "n"], [14, 6, "n"], [15, 6, "n"], [13, 7, "n"], [15, 7, "n"], [13, 8, "n"], [14, 8, "n"], [15, 8, "n"]);
+    const k2 = c < 4 ? 15 : 14;
+    e.push([13, 9, "a"], [13, 10, "a"], [k2, 9, "a"], [k2, 10, "a"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: 1,
+      eyes: c === 7 ? "closed" : "open",
+      extras: e
+    };
+  },
+  map: t => {
+    // A folded map held up: dotted route, red pin; looks around for the way.
+    const c = t % 16;
+    const e = [];
+    rect(3, 8, 12, 11, "l", e);
+    e.push([4, 10, "m"], [5, 9, "m"], [6, 9, "m"], [7, 10, "m"], [8, 10, "m"], [9, 9, "m"], [10, 9, "m"]);
+    e.push([11, 8, "r"], [11, 9, "r"]);
+    e.push([2, 9, "g"], [13, 9, "g"]);
+    const look = c >= 8;
+    return {
+      ...BASE,
+      ex: look ? c < 12 ? -1 : 1 : 0,
+      ey: look ? -1 : 1,
+      legs: null,
+      extras: e
+    };
+  },
+  photo: t => {
+    // A camera held up; flash; a print pops out the side.
+    const c = t % 16;
+    const e = [];
+    rect(5, 8, 10, 10, "n", e);
+    rect(7, 9, 8, 9, "k", e);
+    e.push([7, 9, "l"], [10, 8, "1"]);
+    e.push([2, 9, "g"], [13, 9, "g"]);
+    if (c === 6) {
+      rect(0, 0, 15, 1, "l", e);
+      e.push([3, 2, "l"], [12, 2, "l"]);
+    }
+    if (c >= 8) {
+      rect(13, 6, 15, 8, "n", e);
+      e.push([14, 7, "g"]);
+    }
+    return {
+      ...BASE,
+      lamp: c === 6 ? "a" : "A",
+      eyes: c === 6 ? "closed" : "open",
+      legs: null,
+      extras: e
+    };
+  },
+  painting: t => {
+    // A canvas on the right; strokes appear as the brush works.
+    const c = t % 16;
+    const e = [];
+    rect(13, 2, 15, 7, "l", e);
+    if (c >= 2) e.push([13, 3, "p"], [14, 3, "p"]);
+    if (c >= 6) e.push([14, 5, "a"], [15, 5, "a"]);
+    if (c >= 10) e.push([13, 6, "r"]);
+    e.push([13, 8, "g"], [14, 8, "g"], [15, 8 - c % 2, "m"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: c % 8 < 4 ? -1 : 0,
+      extras: e
+    };
+  },
+  disguise: t => {
+    // Groucho glasses, nose and moustache; sly glances.
+    const e = [];
+    for (const x of [4, 8]) {
+      rect(x, 5, x + 3, 5, "n", e);
+      rect(x, 8, x + 3, 8, "n", e);
+      e.push([x, 6, "n"], [x, 7, "n"], [x + 3, 6, "n"], [x + 3, 7, "n"]);
+    }
+    e.push([7, 8, "a"], [8, 8, "a"]);
+    rect(5, 9, 10, 9, "k", e);
+    e.push([5, 10, "k"], [10, 10, "k"]);
+    return {
+      ...BASE,
+      ex: [-1, -1, -1, 0, 1, 1, 1, 0][Math.floor(t / 3) % 8],
+      extras: e
+    };
+  },
+  pro: t => {
+    // A crown in place of the lamp, jewels, sparkles.
+    const c = t % 12;
+    const e = [];
+    rect(5, 2, 10, 3, "a", e);
+    e.push([5, 1, "a"], [7, 1, "a"], [8, 1, "a"], [10, 1, "a"], [6, 2, "p"], [9, 2, "p"]);
+    e.push(c % 2 ? [3, 1, "l"] : [12, 0, "l"]);
+    return {
+      ...BASE,
+      lamp: null,
+      eyes: c >= 6 ? "happy" : "open",
+      extras: e
+    };
+  },
+  talking: t => {
+    // A speech bubble with typing dots; the lamp pulses as it speaks.
+    const c = t % 12;
+    const e = [];
+    rect(9, 0, 15, 2, "l", e);
+    e.push([10, 3, "l"]);
+    [10, 12, 14].forEach((x, i) => e.push([x, 1, (c + i) % 3 === 0 ? "k" : "m"]));
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      lamp: c % 4 < 2 ? "a" : "A",
+      extras: e
+    };
+  },
+  handshake: t => {
+    // A hand arrives from the right; Otto meets it; they shake.
+    const c = t % 16;
+    const hx = 16 - Math.min(2, c);
+    const dy = c >= 4 && c < 12 ? Math.floor(c / 2) % 2 : 0;
+    const e = [];
+    rect(hx, 6 + dy, hx + 1, 7 + dy, "n", e);
+    if (c >= 2) e.push([13, 7 + dy, "g"]);
+    return {
+      ...BASE,
+      ex: 1,
+      eyes: c >= 4 ? "happy" : "open",
+      extras: e
+    };
+  },
+  robot: t => {
+    // A small robot friend on the right: antenna blinking, eyes flickering.
+    const c = t % 16;
+    const e = [];
+    e.push([14, 3, c % 4 < 2 ? "r" : "n"], [14, 4, "n"]);
+    rect(13, 5, 15, 7, "n", e);
+    const eye = c % 8 < 2 ? "r" : "k";
+    e.push([13, 6, eye], [15, 6, eye]);
+    rect(13, 8, 15, 10, "m", e);
+    e.push([14, 9, "l"], [13, 11, "n"], [15, 11, "n"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: 1,
+      eyes: c >= 8 && c < 12 ? "happy" : "open",
+      extras: e
+    };
+  },
+  plug: t => {
+    // A plug slides in from the right and connects; the lamp comes on.
+    const c = t % 16;
+    const px = 16 - Math.min(3, c);
+    const e = [];
+    rect(px, 6, px + 1, 7, "n", e);
+    e.push([px - 1, 6, "l"], [px - 1, 7, "l"], [px + 2, 7, "n"], [px + 3, 7, "n"]);
+    if (c >= 4 && c < 7) e.push(c % 2 ? [11, 2, "l"] : [15, 4, "l"]);
+    return {
+      ...BASE,
+      lamp: c >= 3 ? "a" : "A",
+      ex: 1,
+      eyes: c >= 5 ? "happy" : "open",
+      extras: e
+    };
+  },
+  gift: t => {
+    // A wrapped gift bounces; the lid lifts with a sparkle.
+    const c = t % 16;
+    const open = c >= 12;
+    const dy = !open && c % 4 === 2 ? -1 : 0;
+    const e = [];
+    rect(13, 7 + dy, 15, 10 + dy, "p", e);
+    rect(14, 7 + dy, 14, 10 + dy, "a", e);
+    const by = open ? 4 : 6 + dy;
+    rect(13, by, 15, by, "a", e);
+    if (open) e.push([14, 3, "l"], [12, 5, "l"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: 1,
+      eyes: open ? "happy" : "big",
+      extras: e
+    };
+  },
+  action: t => {
+    // A clapperboard on the right claps shut.
+    const c = t % 16;
+    const closed = c === 4 || c === 5;
+    const e = [];
+    rect(13, 4, 15, 7, "n", e);
+    e.push([14, 5, "k"], [14, 6, "k"]);
+    const by = closed ? 3 : 2;
+    e.push([13, by, "l"], [14, by, "k"], [15, by, "l"]);
+    if (c === 4) e.push([12, 2, "l"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c === 4 ? "closed" : "open",
+      extras: e
+    };
+  },
+  guard: t => {
+    // A shield up; a red bolt comes in, sparks off it and bounces away.
+    const c = t % 16;
+    const e = [];
+    rect(13, 5, 15, 7, "n", e);
+    e.push([14, 8, "n"], [14, 6, "g"]);
+    if (c % 6 === 0) e.push([13, 5, "l"]);
+    if (c >= 2 && c < 6) e.push([15, c - 2, "r"]);
+    if (c === 6) e.push([15, 4, "l"], [14, 4, "l"]);
+    if (c >= 7 && c < 10) e.push([15, 9 - c, "R"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c === 5 || c === 6 ? "big" : "open",
+      extras: e
+    };
+  },
+  coffee: t => {
+    // A mug with steam; lifts it for a sip, eyes shut, then content.
+    const c = t % 16;
+    const sip = c >= 8 && c < 12;
+    const dy = sip ? -2 : 0;
+    const e = [];
+    rect(13, 6 + dy, 14, 8 + dy, "l", e);
+    e.push([15, 7 + dy, "n"], [13, 6 + dy, "A"], [14, 6 + dy, "A"], [13, 9 + dy, "g"], [14, 9 + dy, "g"]);
+    if (!sip) e.push(...(c % 2 ? [[13, 4, "n"], [14, 3, "n"]] : [[14, 4, "n"], [13, 3, "n"]]));
+    return {
+      ...BASE,
+      ex: sip ? 0 : 1,
+      ey: sip ? 0 : 1,
+      eyes: sip ? "closed" : c >= 12 && c < 14 ? "happy" : "open",
+      extras: e
+    };
+  },
+  swimming: t => {
+    // In the water to the shoulders, alternating strokes with splashes.
+    const c = t % 8;
+    const left = c < 4;
+    const e = left ? [[1, 8, "g"], [2, 9, "g"], [0, 12, "l"], [13, 11, "g"], [14, 12, "g"]] : [[14, 8, "g"], [13, 9, "g"], [15, 12, "l"], [2, 11, "g"], [1, 12, "g"]];
+    return {
+      ...BASE,
+      submerged: true,
+      y0: 8,
+      ex: left ? -1 : 1,
+      legs: null,
+      extras: e
+    };
+  },
+  diving: t => {
+    // Sinks out of sight, bubbles rise, then comes back up dripping.
+    const c = t % 24;
+    const e = [];
+    let y0 = 4;
+    if (c >= 4 && c < 10) y0 = 4 + (c - 3) * 2;else if (c >= 10 && c < 16) y0 = 16;else if (c >= 16 && c < 20) y0 = 14 - (c - 15) * 2;
+    if (c >= 8 && c < 16) e.push([7, 12 - c * 2 % 6, "l"], [9, 12 - (c * 2 + 3) % 6, "l"]);
+    if (c === 20 || c === 21) e.push([3, 3, "l"], [12, 3, "l"]);
+    return {
+      ...BASE,
+      submerged: y0 > 4,
+      y0,
+      ey: c < 4 ? 1 : 0,
+      eyes: c >= 20 && c < 23 ? "happy" : "open",
+      legs: y0 > 4 ? null : [0, 0, 0],
+      extras: e
+    };
+  },
+  balloon: t => {
+    // A balloon lifts Otto clear of the water; a splash when it lets go.
+    const c = t % 24;
+    const y0 = c < 8 ? 4 : c < 20 ? 4 - Math.min(3, Math.floor((c - 8) / 2)) : 4;
+    const e = [];
+    rect(13, 0, 15, 2, "r", e);
+    e.push([14, 3, "R"]);
+    rect(14, 4, 14, y0 + 2, "n", e);
+    e.push([13, y0 + 2, "g"]);
+    if (c === 20) e.push([2, 12, "l"], [12, 12, "l"]);
+    const lifted = y0 < 4;
+    return {
+      ...BASE,
+      y0,
+      ex: lifted ? 0 : 1,
+      ey: lifted ? 0 : -1,
+      eyes: lifted ? "happy" : "open",
+      legs: lifted ? c % 2 ? [1, 0, 1] : [0, 1, 0] : [0, 0, 0],
+      extras: e
+    };
+  },
+  landing: t => {
+    // Drops in from above, lands with a squash and a splash, settles.
+    const c = t % 16;
+    if (c < 4) return {
+      ...BASE,
+      y0: -8 + c * 3,
+      eyes: "big",
+      legs: [1, 1, 1]
+    };
+    if (c === 4) return {
+      ...BASE,
+      x0: 2,
+      w: 12,
+      y0: 6,
+      h: 5,
+      eyes: "closed",
+      extras: [[1, 12, "l"], [14, 12, "l"], [0, 11, "l"], [15, 11, "l"]]
+    };
+    if (c === 5) return {
+      ...BASE,
+      eyes: "closed"
+    };
+    return {
+      ...BASE,
+      eyes: c >= 8 && c < 12 ? "happy" : "open"
+    };
+  },
+  spinning: t => {
+    // A full turn: front, three-quarter, side, back and round again.
+    const c = t % 16;
+    const ph = Math.floor(c / 2);
+    const [w, ex] = [[10, 0], [8, 1], [6, 0], [4, 0], [6, 0], [8, -1], [10, 0], [10, 0]][ph];
+    const x0 = 3 + (10 - w) / 2;
+    const e = [];
+    if (w <= 6) {
+      const x1 = x0 + w - 1;
+      e.push([x0 + 1, 11, "s"], [x0 + 1, 12, "s"], [x1 - 1, 11, "s"], [x1 - 1, 12, "s"]);
+    }
+    if (w === 4) rect(x0, 6, x0 + 3, 7, "g", e);
+    return {
+      ...BASE,
+      x0,
+      w,
+      ex,
+      legs: w <= 6 ? null : [0, 0, 0],
+      extras: e
+    };
+  },
+  bubbles: t => {
+    // Blows through a bubble wand; bubbles drift up and away.
+    const c = t % 12;
+    const blow = c < 4;
+    const e = [[13, 6, "g"], [14, 6, "g"], [15, 6, "m"], [15, 5, "m"], [15, 4, "n"]];
+    for (let i = 0; i < 3; i++) {
+      const y = 3 - (c + i * 4) % 12;
+      if (y >= 0) e.push([13 + i % 2, y, "l"]);
+    }
+    return {
+      ...BASE,
+      ex: blow ? 1 : 1,
+      ey: blow ? 0 : -1,
+      eyes: blow ? "closed" : "open",
+      extras: e
+    };
+  },
+  trash: t => {
+    // Bits fly into a bin, the lid flaps, a puff when it's done.
+    const c = t % 16;
+    const e = [];
+    rect(13, 7, 15, 11, "n", e);
+    rect(14, 8, 14, 10, "1", e);
+    const open = c >= 2 && c < 10;
+    rect(13, open ? 5 : 6, 15, open ? 5 : 6, "n", e);
+    if (c >= 3 && c < 9) e.push([7 + (c - 3), 5 - c % 2, c % 2 ? "p" : "a"]);
+    if (c === 9 || c === 10) e.push([14, 4, "l"], [13, 3, "l"], [15, 3, "l"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c >= 11 && c < 14 ? "happy" : "open",
+      extras: e
+    };
+  },
+  saved: t => {
+    // A floppy disk pops in; a hop and a sparkle.
+    const c = t % 12;
+    const dy = c === 1 ? -1 : 0;
+    const e = [];
+    if (c >= 1) {
+      rect(13, 2 + dy, 15, 5 + dy, "1", e);
+      e.push([13, 2 + dy, "n"], [14, 2 + dy, "n"]);
+      rect(13, 4 + dy, 15, 5 + dy, "l", e);
+    }
+    if (c === 3 || c === 4) e.push([12, 0, "l"], [15, 7, "l"]);
+    const hop = c === 2 ? 1 : 0;
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      ex: 1,
+      ey: -1,
+      eyes: c >= 3 ? "happy" : "open",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  copied: t => {
+    // One sheet slides out from behind another; a sparkle.
+    const c = t % 12;
+    const off = c < 2 ? 0 : 1;
+    const e = [];
+    rect(12, 1, 14, 3, "n", e);
+    e.push([13, 2, "1"]);
+    rect(12 + off, 2 + off, 14 + off, 4 + off, "l", e);
+    e.push([13 + off, 3 + off, "m"]);
+    if (c === 4 || c === 5) e.push([15, 0, "l"], [11, 6, "l"]);
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c >= 4 ? "happy" : "open",
+      extras: e
+    };
+  },
+  charting: t => {
+    // Three bars grow on the right; pleased when they land.
+    const c = t % 16;
+    const e = [];
+    rect(13, 12, 15, 12, "n", e);
+    [3, 5, 4].forEach((target, i) => {
+      const h = Math.min(target, Math.floor(c / 2));
+      if (h > 0) rect(13 + i, 12 - h, 13 + i, 11, "g", e);
+    });
+    return {
+      ...BASE,
+      ex: 1,
+      ey: c < 6 ? 1 : 0,
+      eyes: c >= 12 ? "happy" : "open",
+      extras: e
+    };
+  },
+  // ── Pairing poses ───────────────────────────────────────────────────────
+  // Built to hold something that is NOT in the grid — a tool's icon tile,
+  // drawn by the scene at OTTO_ANCHORS[state](t). The right-hand prop zone is
+  // kept clear on purpose.
+  present: t => {
+    // A flat hand held out; the object floats above the palm and bobs.
+    const c = t % 16;
+    const e = [[13, 7, "g"], [14, 7, "g"], [15, 7, "g"], [15, 6, "g"]];
+    return {
+      ...BASE,
+      ex: 1,
+      ey: -1,
+      eyes: c === 13 ? "closed" : c >= 8 && c < 12 ? "happy" : "open",
+      extras: e
+    };
+  },
+  lift: t => {
+    // Both arms up; the object rides above the head; a hop every eight ticks.
+    const c = t % 16;
+    const hop = c % 8 === 2 || c % 8 === 3 ? 1 : 0;
+    const e = [[2, 5 - hop, "g"], [1, 4 - hop, "g"], [1, 3 - hop, "g"], [13, 5 - hop, "g"], [14, 4 - hop, "g"], [14, 3 - hop, "g"]];
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      eyes: "happy",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  carry: t => {
+    // Arms up, marching; the object rides overhead with the step.
+    const b = Math.floor(t / 2) % 2;
+    const e = [[2, 5 + b, "g"], [1, 4 + b, "g"], [1, 3 + b, "g"], [13, 5 + b, "g"], [14, 4 + b, "g"], [14, 3 + b, "g"]];
+    return {
+      ...BASE,
+      y0: 4 + b,
+      ex: t % 16 < 8 ? 0 : 1,
+      legs: walk(t),
+      extras: e
+    };
+  },
+  hug: t => {
+    // Arms wrapped round the object held against the body; eyes peep over it.
+    const c = t % 16;
+    const b = Math.floor(c / 8) % 2;
+    const e = [[1, 7 + b, "g"], [2, 8 + b, "g"], [14, 7 + b, "g"], [13, 8 + b, "g"]];
+    return {
+      ...BASE,
+      y0: 4 + b,
+      ey: -1,
+      eyes: c >= 4 && c < 12 ? "happy" : "closed",
+      extras: e
+    };
+  },
+  lean: t => {
+    // One arm resting on the object standing beside Otto; relaxed.
+    const c = t % 24;
+    const e = [[13, 5, "g"], [14, 5, "g"], [15, 5, "g"]];
+    return {
+      ...BASE,
+      ex: c < 16 ? 1 : 0,
+      eyes: c >= 8 && c < 12 ? "closed" : "open",
+      legs: [0, 1, 0],
+      extras: e
+    };
+  },
+  point: t => {
+    // Arm up and out; the object hangs up-right, bobbing; a hop of delight.
+    const c = t % 16;
+    const hop = c === 6 || c === 7 ? 1 : 0;
+    const e = [[13, 5 - hop, "g"], [14, 4 - hop, "g"], [15, 3 - hop, "g"]];
+    return {
+      ...BASE,
+      y0: 4 - hop,
+      ex: 1,
+      ey: -1,
+      eyes: c >= 6 && c < 10 ? "happy" : "open",
+      legs: hop ? [1, 1, 1] : [0, 0, 0],
+      extras: e
+    };
+  },
+  static: () => ({
+    ...BASE
+  })
+};
+
+/** Where a held object sits, in grid cells (may run past the 16×16 grid). */
+
+/**
+ * The pairing poses' object anchors at tick `t`, for a 7×7-cell object — a
+ * tool icon tile. Bobs follow the pose so the object moves with the hands.
+ */
+const OTTO_ANCHORS = exports.OTTO_ANCHORS = {
+  present: t => ({
+    x: 14,
+    y: -1 + Math.floor(t % 16 / 4) % 2,
+    over: false
+  }),
+  lift: t => {
+    const c = t % 16;
+    const hop = c % 8 === 2 || c % 8 === 3 ? 1 : 0;
+    return {
+      x: 4,
+      y: -5 - hop,
+      over: false
+    };
+  },
+  carry: t => ({
+    x: 4,
+    y: -5 + Math.floor(t / 2) % 2,
+    over: false
+  }),
+  hug: t => ({
+    x: 4,
+    y: 7 + Math.floor(t % 16 / 8) % 2,
+    over: true
+  }),
+  lean: () => ({
+    x: 14,
+    y: 6,
+    over: false
+  }),
+  point: t => {
+    const c = t % 16;
+    const hop = c === 6 || c === 7 ? 1 : 0;
+    return {
+      x: 15,
+      y: -5 - hop + Math.floor(c / 4) % 2,
+      over: false
+    };
+  }
+};
+
+/** The object size OTTO_ANCHORS is drawn for, in cells. */
+const OTTO_ANCHOR_SIZE = exports.OTTO_ANCHOR_SIZE = 7;
+const OTTO_NOTES = exports.OTTO_NOTES = {
+  idle: "Bobs one pixel, blinks, glances left and right.",
+  thinking: "Looks up; a thought cloud fills with dots.",
+  happy: "Two-pixel hop: stretch on takeoff, squash on landing.",
+  error: "Lamp goes red, eyes shut, body shakes.",
+  sleep: "Sinks a row, lamp dims, z’s drift up.",
+  peek: "Submerged to the eyes, scanning.",
+  typing: "Laptop with a Buoy screen; tentacles tap.",
+  debugging: "Magnifier over one eye, scanning left and right.",
+  building: "Hard hat, hammer swings, spark on the hit.",
+  carrying: "Phone overhead, marching.",
+  pushing: "Shoves a crate, one pixel per heave.",
+  sweeping: "Broom, dust puff on each stroke.",
+  juggling: "Three blocks: red, orange, purple.",
+  wizard: "Purple hat, wand sparkles.",
+  conducting: "Arms swing in antiphase, notes rise.",
+  beacon: "Lamp emits three expanding rings.",
+  notification: "Hop with a blinking exclamation.",
+  disconnected: "Lamp dim, looks up at a phone blinking red.",
+  dizzy: "X eyes, two stars orbit, body wobbles.",
+  overheated: "Melts into a puddle and reforms.",
+  confused: "Question mark, head tilt, eyes wander.",
+  stare: "Big square eyes. Rare blink.",
+  walking: "Crab-walks left and right, eyes lead.",
+  goingaway: "Walks off the right edge, returns from the left.",
+  eureka: "Bulb appears, lights up with sparks, tiny hops.",
+  grooving: "Headphones on, sways with the beat, notes pop.",
+  hatmishap: "Wizard hat slips over the eyes; a wave of the wand fixes it.",
+  lowbattery: "Slumped, lamp off, red battery blinks. Eyes barely open.",
+  wake: "Puddle, wide eyes, springs up, squashes, settles.",
+  builder: "Balances a stack of blocks; sweat drop when it wobbles.",
+  mini: "Half-size Otto. Big eyes, waving arms, kicking feet.",
+  minityping: "Mini Otto typing, data bits float up.",
+  happydance: "Arms pump in antiphase, feet shuffle.",
+  jumping: "Crouch, four-pixel leap, arms up, land.",
+  loading: "Three dots chase around a ring; eyes follow the lead.",
+  progress: "A bar fills across the top; a hop when it completes.",
+  hourglass: "Sand runs through, the glass lifts and flips.",
+  waiting: "Foot taps, checks the wristwatch, dots pile up.",
+  syncing: "Two arcs chase each other; lamp pulses in step.",
+  downloading: "An arrow drops into the tray, the parcel lands.",
+  uploading: "The parcel lifts off the tray and climbs out.",
+  connecting: "Signal bars fill one by one, then blink: connected.",
+  scanning: "A bright line sweeps down the body with a trail.",
+  searching: "Binoculars up, slow sweep left and right.",
+  empty: "Peers into an open box, finds nothing, looks back at you.",
+  shrug: "Arms up, looks left, looks right, arms down.",
+  fishing: "Rod out, bobber bobbing; one tug, one splash.",
+  listening: "Hand cupped, sound arcs arriving from the side.",
+  tumbleweed: "A tumbleweed rolls past; eyes follow it off the edge.",
+  warning: "Holds up a warning sign, lamp blinking.",
+  crash: "Burst, smoke, then dazed with X eyes.",
+  panic: "Arms flail, sweat flies, lamp strobes.",
+  sos: "The lamp flashes S-O-S in morse; arms wave.",
+  offline: "A struck-through cloud; slumped, lamp dim.",
+  timeout: "A clock ticks round, turns red; a shake.",
+  locked: "A padlock: look, strain at it, give up.",
+  unlocked: "The shackle pops open; sparkles and a hop.",
+  denied: "A red no-entry sign; head shaking.",
+  broken: "A crack down the middle; a band-aid goes on.",
+  sad: "Sunk a row, lamp dim, a tear drops in.",
+  rain: "A rain cloud overhead, drops falling.",
+  sick: "A thermometer climbs; wobbling and sweating.",
+  flood: "In over the eyes, arms flailing, bubbles rising.",
+  bug: "A beetle crawls across the body, then flies off.",
+  alarm: "The lamp is a siren: red strobe, sweeping rays.",
+  frozen: "Iced over: icicles for legs, snow, shivering.",
+  snail: "A snail crosses the foreground, very slowly.",
+  angry: "Brows down, lamp red, steam, stomping.",
+  ghost: "Grey and translucent, floating, white eyes.",
+  nervous: "Eyes darting, sweat, fidgeting feet.",
+  puzzled: "A tentacle scratches the head; eyes wander.",
+  detective: "Deerstalker hat, magnifying glass on the move.",
+  reading: "An open book; eyes run the lines; a page turns.",
+  success: "A check mark lands; sparkles, a hop, lamp blinks.",
+  celebrate: "Confetti falls, arms up, bouncing.",
+  thumbsup: "A fist rises, thumb out; then a wink.",
+  party: "Party hat, confetti, a side-to-side dance.",
+  trophy: "A cup held overhead, sparkles, a hop.",
+  starred: "A star pops in at the top right and twinkles.",
+  love: "Hearts float up either side; the body bobs.",
+  wave: "One arm up, hand swinging; a smile at the end.",
+  bow: "A slow bow: squash forward, eyes shut, back up.",
+  cool: "Sunglasses drop into place; a little sway.",
+  flexing: "Both arms up in a flex; the biceps pop.",
+  zen: "Floating above the water, eyes shut, slow bob.",
+  recording: "A red REC dot blinks; eyes slowly sweep the room.",
+  paused: "Pause bars overhead; resting, lamp dim, one peek.",
+  filtering: "A funnel: mixed bits go in, only orange comes out.",
+  pinned: "A pushpin drops in from above and lands.",
+  rewind: "Moonwalks left while a clock runs backwards.",
+  storing: "Crates stack up on the right, one at a time.",
+  printing: "A little printer spools out a strip of log lines.",
+  stopwatch: "A stopwatch with a fast hand; speed lines.",
+  spotlight: "The lamp throws a beam that sweeps left, up, right.",
+  keys: "A keyring held out; the keys jingle.",
+  map: "A folded map: dotted route, red pin; looks around.",
+  photo: "A camera held up; flash; a print pops out.",
+  painting: "A canvas on the right; strokes appear.",
+  disguise: "Groucho glasses, nose and moustache; sly glances.",
+  pro: "A crown in place of the lamp, jewels, sparkles.",
+  talking: "A speech bubble with typing dots; lamp pulses.",
+  handshake: "A hand arrives from the right; they shake.",
+  robot: "A small robot friend: antenna blinking, eyes flickering.",
+  plug: "A plug slides in and connects; the lamp comes on.",
+  gift: "A wrapped gift bounces; the lid lifts with a sparkle.",
+  action: "A clapperboard claps shut.",
+  guard: "A shield up; a red bolt sparks off it and bounces away.",
+  coffee: "A mug with steam; a sip with eyes shut.",
+  swimming: "In to the shoulders, alternating strokes with splashes.",
+  diving: "Sinks out of sight, bubbles rise, comes back dripping.",
+  balloon: "A balloon lifts Otto clear of the water; a splash on release.",
+  landing: "Drops in from above, lands with a squash and a splash.",
+  spinning: "A full turn: front, three-quarter, side, back and round.",
+  bubbles: "Blows through a bubble wand; bubbles drift up.",
+  trash: "Bits fly into a bin, the lid flaps, a puff when done.",
+  saved: "A floppy disk pops in; a hop and a sparkle.",
+  copied: "One sheet slides out from behind another.",
+  charting: "Three bars grow on the right; pleased when they land.",
+  present: "A flat hand held out; the object floats above the palm.",
+  lift: "Both arms up; the object rides overhead; a hop.",
+  carry: "Arms up, marching; the object rides with the step.",
+  hug: "Arms wrapped round the object; eyes peep over it.",
+  lean: "One arm resting on the object beside Otto; relaxed.",
+  point: "Arm up and out; the object hangs up-right, bobbing.",
+  static: "Base pose, no motion. For favicons and stills."
+};
+
+/** Every animated state, in the mockup's order (`static` excluded). */
+const OTTO_STATE_NAMES = exports.OTTO_STATE_NAMES = Object.keys(OTTO_STATES).filter(n => n !== "static");
+/**
+ * The states by job. Every animated state is in exactly one group; a tool
+ * picks from the group that matches the moment (an empty list shows an
+ * `empty` group state, a failed request a `trouble` one, and so on).
+ */
+const OTTO_GROUPS = exports.OTTO_GROUPS = [{
+  id: "loading",
+  title: "Loading & progress",
+  blurb: "Something is on its way. Spinners, bars, connecting, scanning, waiting.",
+  states: ["loading", "progress", "hourglass", "waiting", "syncing", "downloading", "uploading", "connecting", "scanning", "searching", "fishing"]
+}, {
+  id: "empty",
+  title: "Empty & unknown",
+  blurb: "Nothing here yet, nothing found, or no idea what this is.",
+  states: ["empty", "shrug", "tumbleweed", "confused", "puzzled"]
+}, {
+  id: "trouble",
+  title: "Errors & trouble",
+  blurb: "Failures, warnings, disconnects, limits — from a blip to a crash.",
+  states: ["error", "warning", "crash", "panic", "sos", "alarm", "offline", "disconnected", "timeout", "locked", "denied", "broken", "sad", "rain", "sick", "overheated", "dizzy", "flood", "bug", "frozen", "snail", "angry", "ghost", "nervous", "lowbattery"]
+}, {
+  id: "success",
+  title: "Success & celebration",
+  blurb: "It worked. Confirmations, unlocks, milestones, thanks.",
+  states: ["happy", "eureka", "success", "celebrate", "thumbsup", "party", "trophy", "starred", "love", "unlocked", "notification", "beacon", "cool", "flexing", "pro", "gift"]
+}, {
+  id: "working",
+  title: "Working & tool moments",
+  blurb: "Busy doing the job: capturing, filtering, saving, inspecting, talking.",
+  states: ["thinking", "typing", "debugging", "building", "carrying", "pushing", "sweeping", "detective", "reading", "map", "painting", "photo", "printing", "storing", "charting", "stopwatch", "spotlight", "keys", "filtering", "talking", "listening", "recording", "paused", "rewind", "trash", "disguise", "guard", "action", "robot", "plug", "handshake", "saved", "copied", "pinned"]
+}, {
+  id: "personality",
+  title: "Idle, moves & personality",
+  blurb: "Otto being Otto: idling, wandering, swimming, dancing, showing off.",
+  states: ["idle", "stare", "mini", "minityping", "walking", "goingaway", "peek", "sleep", "wake", "jumping", "spinning", "swimming", "diving", "balloon", "landing", "bubbles", "zen", "bow", "wave", "coffee", "grooving", "conducting", "juggling", "wizard", "hatmishap", "builder", "happydance"]
+}, {
+  id: "pairing",
+  title: "Pairing poses",
+  blurb: "Built to hold a tool's icon tile — the object is drawn by the scene at OTTO_ANCHORS.",
+  states: ["present", "lift", "carry", "hug", "lean", "point"]
+}];
+
+/** When to reach for each state — the moment in a tool it was drawn for. */
+const OTTO_USES = exports.OTTO_USES = {
+  idle: "Default resting state; nothing to report.",
+  thinking: "Working something out; Ask Buoy composing.",
+  happy: "A quick positive beat after any action.",
+  error: "A request or action failed.",
+  sleep: "Tool idle for a long time; capture off overnight.",
+  peek: "Minimized or collapsed; still watching.",
+  typing: "Ask Buoy typing a reply; code being written.",
+  debugging: "Inspecting a detail view; stepping through.",
+  building: "Bundling, compiling, a build in progress.",
+  carrying: "Moving data between tools; exporting.",
+  pushing: "A heavy job: large payload, slow migration.",
+  sweeping: "Clearing a list; cache cleanup done.",
+  juggling: "Several stores or queries updating at once.",
+  wizard: "A setup wizard; magic done on your behalf.",
+  conducting: "Orchestrating a flow or scenario.",
+  beacon: "Broadcasting: broker up, dashboard discoverable.",
+  notification: "A new item arrived; badge count went up.",
+  disconnected: "Device or dashboard connection dropped.",
+  dizzy: "Too many re-renders; a render storm.",
+  overheated: "CPU or thermal pressure; perf meltdown.",
+  confused: "Unknown or unparseable data.",
+  stare: "Watching for a specific event; recording armed.",
+  walking: "Navigating between routes.",
+  goingaway: "Leaving a screen; a tool closing.",
+  eureka: "Root cause found; a diff that explains it.",
+  grooving: "Everything healthy; nothing to do but vibe.",
+  hatmishap: "A small recoverable slip; retry worked.",
+  lowbattery: "Device battery low; power-saving mode.",
+  wake: "Tool re-opened; capture resumed.",
+  builder: "Assembling a state tree or fixture.",
+  mini: "Compact or inline placements.",
+  minityping: "A compact typing indicator.",
+  happydance: "A milestone: all tests green, release done.",
+  jumping: "Jump to a route, a log line, a snapshot.",
+  loading: "Generic indeterminate loading.",
+  progress: "Determinate progress: download, batch, upload.",
+  hourglass: "Waiting on a timer; a scheduled retry.",
+  waiting: "Waiting for a device, the first event, a reply.",
+  syncing: "Syncing with the desktop dashboard or broker.",
+  downloading: "Pulling a snapshot, an update, a payload.",
+  uploading: "Sending a report, a snapshot, feedback.",
+  connecting: "Connecting to a device or broker.",
+  scanning: "Scanning for targets, keys, assets, fibers.",
+  searching: "A search running; filtering a long list.",
+  fishing: "Capture on, nothing captured yet.",
+  empty: "An empty list: no requests, no logs, no keys.",
+  shrug: "No result and no explanation available.",
+  tumbleweed: "Deliberately empty; nothing happened for a while.",
+  puzzled: "Unexpected shape; needs a second look.",
+  warning: "A warning: deprecated, risky, near a limit.",
+  crash: "The app crashed; a fatal was captured.",
+  panic: "Many errors at once; an error cascade.",
+  sos: "Critical: the app cannot continue.",
+  alarm: "An alert rule fired; attention now.",
+  offline: "No network; device offline.",
+  timeout: "A request or connection timed out.",
+  locked: "A Pro feature; a locked setting.",
+  denied: "Permission denied; blocked by policy.",
+  broken: "Corrupted data; a broken persisted value.",
+  sad: "Nothing matched; a failed search.",
+  rain: "A bad run: errors piling up.",
+  sick: "Unhealthy config; env check failing.",
+  flood: "Buffer full; too many events to keep up.",
+  bug: "A bug was found (or is being reported).",
+  frozen: "The UI thread froze; a hung frame.",
+  snail: "Slow: a long request, a slow render.",
+  angry: "Rate limited, rejected, forbidden.",
+  ghost: "Stale or detached: an unmounted component, an old snapshot.",
+  nervous: "A risky action pending confirmation.",
+  detective: "Investigating; root-cause analysis.",
+  reading: "Reading docs or a long log.",
+  success: "Action completed; a rule saved, a replay done.",
+  celebrate: "A big success: first capture, setup complete.",
+  thumbsup: "Approved; looks good; confirmation received.",
+  party: "Release shipped; a version milestone.",
+  trophy: "Best benchmark yet; a personal record.",
+  starred: "Pinned, favourited, starred.",
+  love: "Thanks and delight; feedback sent.",
+  unlocked: "Pro unlocked; license activated.",
+  cool: "Perfect score; zero warnings.",
+  flexing: "Fast: a great perf result.",
+  zen: "All quiet; nothing needs attention.",
+  pro: "Pro plan active.",
+  gift: "New version or feature available.",
+  map: "Route inspector; where am I in the navigator.",
+  photo: "Screenshot taken; image captured.",
+  painting: "Assets and design overlays; theming.",
+  printing: "Console streaming; logs arriving.",
+  storing: "Saving to storage; persisting.",
+  charting: "Metrics building up; perf charts.",
+  stopwatch: "Benchmark running; timing a request.",
+  spotlight: "Highlighting renders; spotlight on a component.",
+  keys: "Environment variables and secrets.",
+  filtering: "Filters active; a subset shown.",
+  talking: "Ask Buoy answering; a message in flight.",
+  listening: "Listening for events; waiting for input.",
+  recording: "Capture on; recording a session.",
+  paused: "Capture paused.",
+  rewind: "Time Machine: stepping back through snapshots.",
+  trash: "Cleared: list emptied, cache purged.",
+  disguise: "Impersonating another user.",
+  guard: "Sentry or a guard rail caught something.",
+  action: "A scenario or flow started.",
+  robot: "The MCP agent is driving the tools.",
+  plug: "Device connected; plugin installed.",
+  handshake: "Paired with the desktop dashboard.",
+  saved: "Saved: request, snapshot, rule.",
+  copied: "Copied to clipboard.",
+  pinned: "Item pinned; survives clears.",
+  spinning: "Refreshing; reloading the app.",
+  swimming: "Making progress through a long job.",
+  diving: "Drilling into a detail or nested value.",
+  balloon: "Upgrading; a plan change in progress.",
+  landing: "Tool mounted; first open.",
+  bubbles: "A light idle for empty side panels.",
+  bow: "Thank you; a graceful exit.",
+  wave: "Welcome; onboarding; first run.",
+  coffee: "A long build; take a break.",
+  present: "Presenting a tool: onboarding, a tool's intro card.",
+  lift: "Showing off a tool: a feature announcement.",
+  carry: "Bringing a tool along: install, add-to-dial.",
+  hug: "A favourite tool: pinned, most used.",
+  lean: "A tool at rest: its idle or settings screen.",
+  point: "Pointing at a tool: a hint, a next step.",
+  static: "Favicons, stills, icons."
+};
+
+/** Cycle lengths that differ from the 16-tick default (used by the reel). */
+const OTTO_CYCLE = {
+  progress: 32,
+  hourglass: 20,
+  fishing: 32,
+  tumbleweed: 28,
+  crash: 20,
+  sos: 34,
+  locked: 20,
+  unlocked: 20,
+  broken: 24,
+  snail: 36,
+  reading: 24,
+  storing: 24,
+  diving: 24,
+  balloon: 24,
+  swimming: 8,
+  scanning: 14,
+  connecting: 14,
+  loading: 10,
+  syncing: 10,
+  downloading: 12,
+  uploading: 12,
+  alarm: 8,
+  flood: 8,
+  panic: 8,
+  nervous: 8,
+  keys: 8,
+  flexing: 8
+};
+
+/** The demo reel: [state, frames]. */
+const OTTO_REEL = exports.OTTO_REEL = [["idle", 30], ["thinking", 20], ["typing", 20], ["happy", 14], ["debugging", 18], ["idle", 14], ["building", 16], ["carrying", 14], ["pushing", 14], ["sweeping", 14], ["juggling", 16], ["wizard", 14], ["conducting", 14], ["beacon", 14], ["notification", 16], ["error", 12], ["disconnected", 14], ["dizzy", 14], ["overheated", 24], ["confused", 18], ["stare", 20], ["walking", 32], ["eureka", 24], ["grooving", 16], ["hatmishap", 32], ["builder", 16], ["happydance", 12], ["jumping", 16], ["mini", 16], ["minityping", 12], ["lowbattery", 24], ["sleep", 24], ["wake", 30], ["peek", 18], ["goingaway", 26],
+// Everything after the original set, one full cycle each.
+...["loading", "progress", "hourglass", "waiting", "syncing", "downloading", "uploading", "connecting", "scanning", "searching", "fishing", "empty", "shrug", "tumbleweed", "puzzled", "warning", "crash", "panic", "sos", "alarm", "offline", "timeout", "locked", "unlocked", "denied", "broken", "sad", "rain", "sick", "flood", "bug", "frozen", "snail", "angry", "ghost", "nervous", "detective", "reading", "success", "celebrate", "thumbsup", "party", "trophy", "starred", "love", "wave", "bow", "cool", "flexing", "zen", "recording", "paused", "filtering", "pinned", "rewind", "storing", "printing", "stopwatch", "spotlight", "keys", "map", "photo", "painting", "disguise", "pro", "talking", "handshake", "robot", "plug", "gift", "action", "guard", "coffee", "swimming", "diving", "balloon", "landing", "spinning", "bubbles", "trash", "saved", "copied", "charting", "present", "lift", "carry", "hug", "lean", "point"].map(s => [s, OTTO_CYCLE[s] ?? 16])];
+const REEL_LENGTH = OTTO_REEL.reduce((a, s) => a + s[1], 0);
+
+/** Which reel state plays at tick `t`, and how far into it we are. */
+function ottoReel(t) {
+  let c = (t % REEL_LENGTH + REEL_LENGTH) % REEL_LENGTH;
+  for (const [state, len] of OTTO_REEL) {
+    if (c < len) return {
+      state,
+      local: c
+    };
+    c -= len;
+  }
+  return {
+    state: "idle",
+    local: 0
+  };
+}
+
+/**
+ * One frame of one state as a 16×16 grid of palette keys (`.` = transparent).
+ * Look colours up in `OTTO_PALETTE`.
+ */
+function renderOttoFrame(state, t, opts = {}) {
+  const local = Math.max(0, Math.floor(t));
+  const pose = OTTO_STATES[state](local);
+  return compose(draw(pose), local, {
+    water: opts.water ?? true,
+    keyline: opts.keyline ?? true,
+    submerged: !!pose.submerged
+  });
+}
+
+/** A horizontal run of one colour — what the renderer actually draws. */
+
+/**
+ * Run-length encode a frame into coloured spans, skipping transparency. A
+ * 16×16 frame is ~256 cells but only ~40–70 runs, which is what keeps a
+ * screen full of animating sprites cheap on Fabric.
+ */
+function ottoRuns(grid) {
+  const runs = [];
+  for (let y = 0; y < grid.length; y++) {
+    const row = grid[y];
+    let x = 0;
+    while (x < row.length) {
+      const key = row[x];
+      let w = 1;
+      while (x + w < row.length && row[x + w] === key) w++;
+      if (key !== ".") {
+        const color = OTTO_PALETTE[key];
+        if (color) runs.push({
+          x,
+          y,
+          w,
+          color
+        });
+      }
+      x += w;
+    }
+  }
+  return runs;
+}