diff --git a/xbox/fiapup/index.html b/xbox/fiapup/index.html
new file mode 100644
index 0000000000..a14e85ad91
--- /dev/null
+++ b/xbox/fiapup/index.html
@@ -0,0 +1,128 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>fiapup</title>
+<style>
+  :root { --bg: #c4e0f0; --ink: #4a3a34; --soft: #6b7c96; }
+  @media (prefers-color-scheme: dark) { :root { --bg: #1d2430; --ink: #e8dccf; --soft: #9aa8c0; } }
+  html, body { margin: 0; height: 100%; background: var(--bg); color: var(--ink);
+    font: 15px/1.4 ui-rounded, system-ui, sans-serif; overflow: hidden; }
+  #stage { position: absolute; inset: 0 0 34px 0; display: grid; place-items: center; }
+  #frame { position: relative; aspect-ratio: 16 / 9; width: min(100vw, calc((100vh - 34px) * 16 / 9)); }
+  #frame canvas { position: absolute; inset: 0; width: 100%; height: 100%; }
+  #keys { position: absolute; left: 0; right: 0; bottom: 0; height: 34px; display: flex;
+    gap: 18px; justify-content: center; align-items: center; color: var(--soft); font-size: 13px; }
+  kbd { font: inherit; padding: 1px 6px; border: 1px solid currentColor; border-radius: 5px; }
+</style>
+</head>
+<body>
+<div id="stage"><div id="frame"><canvas id="scene"></canvas><canvas id="text"></canvas></div></div>
+<div id="keys">
+  <span><kbd>WASD</kbd>/<kbd>arrows</kbd> hand</span>
+  <span><kbd>space</kbd> A pet / pick up / throw</span>
+  <span><kbd>C</kbd> B call</span>
+  <span><kbd>T</kbd> X treat (hold)</span>
+  <span><kbd>R</kbd> Y play</span>
+  <span>or an Xbox pad</span>
+</div>
+<script type="module">
+// fiapup's web shell: the console's bindings, in a browser. The game draws
+// through its own copy of the frame interpreter into `triangle3d` (the same
+// depth-tested WebGL scene oskiewar uses) and `write`; it reads `gamepad(0)`.
+import WebGLOskiewarScene3D from "./live/scene3d-webgl.mjs";
+
+const W = 1920, H = 1080;
+const sceneCanvas = document.querySelector("#scene");
+const textCanvas = document.querySelector("#text");
+const ctx = textCanvas.getContext("2d");
+const scene = new WebGLOskiewarScene3D(sceneCanvas);
+scene.setLogicalSize(W, H);
+let clear = [0, 0, 0, 1];
+
+function fit() {
+  const dpr = Math.min(2, devicePixelRatio || 1), rect = sceneCanvas.getBoundingClientRect();
+  const w = Math.max(1, Math.round(rect.width * dpr)), h = Math.max(1, Math.round(rect.height * dpr));
+  scene.resize(w, h);
+  if (textCanvas.width !== w) textCanvas.width = w;
+  if (textCanvas.height !== h) textCanvas.height = h;
+}
+addEventListener("resize", fit);
+fit();
+
+// ——— the bindings ———
+const t0 = performance.now();
+const host = {
+  runtime: () => ({ width: W, height: H, monotonicUs: Math.round((performance.now() - t0) * 1000) }),
+  triangle3d: (...a) => scene.triangle3d(...a),
+  wipe: (r, g, b) => { clear = [r / 255, g / 255, b / 255, 1]; },
+  box: (x, y, w, h, r, g, b) => { ctx.fillStyle = `rgb(${r},${g},${b})`; ctx.fillRect(x, y, w, h); },
+  line: () => {},
+  write: (s, x, y, size = 32, r = 255, g = 255, b = 255) => {
+    ctx.fillStyle = `rgb(${r},${g},${b})`;
+    ctx.font = `600 ${size}px ui-rounded, "Comic Sans MS", system-ui, sans-serif`;
+    ctx.textBaseline = "top";
+    ctx.fillText(s, x, y);
+  },
+  synth, gamepad,
+};
+
+// ——— sound: one sine with a quick decay, like the console's synth ———
+let audio = null;
+const unlock = () => { audio ||= new AudioContext(); audio.resume?.(); };
+addEventListener("keydown", unlock); addEventListener("pointerdown", unlock);
+function synth(frequency, duration = .1) {
+  if (!audio || audio.state !== "running") return;
+  const at = audio.currentTime, osc = audio.createOscillator(), gain = audio.createGain();
+  osc.frequency.value = frequency;
+  gain.gain.setValueAtTime(.18, at);
+  gain.gain.exponentialRampToValueAtTime(.0001, at + duration + .05);
+  osc.connect(gain).connect(audio.destination);
+  osc.start(at); osc.stop(at + duration + .06);
+}
+
+// ——— the pad: an Xbox controller if there is one, else the keyboard ———
+const keys = new Set();
+const keyMap = { KeyW: "ArrowUp", ArrowUp: "ArrowUp", KeyS: "ArrowDown", ArrowDown: "ArrowDown",
+  KeyA: "ArrowLeft", ArrowLeft: "ArrowLeft", KeyD: "ArrowRight", ArrowRight: "ArrowRight",
+  Space: "A", Enter: "A", KeyC: "B", KeyT: "X", KeyR: "Y", Escape: "Menu" };
+addEventListener("keydown", (e) => { const k = keyMap[e.code]; if (k) { keys.add(k); e.preventDefault(); } });
+addEventListener("keyup", (e) => { const k = keyMap[e.code]; if (k) keys.delete(k); });
+addEventListener("blur", () => keys.clear());
+const padNames = ["A", "B", "X", "Y", "LeftShoulder", "RightShoulder", "LeftTrigger", "RightTrigger",
+  "View", "Menu", "LeftThumb", "RightThumb", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
+function gamepad() {
+  const down = new Set(keys);
+  const pad = [...(navigator.getGamepads?.() || [])].find((p) => p?.connected);
+  pad?.buttons.forEach((b, i) => { if (b.pressed && padNames[i]) down.add(padNames[i]); });
+  return { connected: true, down: [...down], leftX: pad?.axes[0] || 0, leftY: -(pad?.axes[1] || 0) };
+}
+
+// ——— the game ———
+const source = await (await fetch("./fiapup.js", { cache: "no-store" })).text();
+const names = Object.keys(host);
+const game = new Function(...names, `${source}\nreturn { boot, sim, paint, act, leave, fiapup };`)(
+  ...names.map((n) => host[n]));
+game.boot();
+const params = new URLSearchParams(location.search);
+if (params.get("stage")) game.fiapup.stage(params.get("stage"), Number(params.get("seconds")) || 2.5);
+const paused = params.has("pause");
+globalThis.__fiapup = game.fiapup;
+
+function frame() {
+  const s = textCanvas.width / W;
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  ctx.clearRect(0, 0, textCanvas.width, textCanvas.height);
+  ctx.setTransform(s, 0, 0, s, 0, 0);
+  scene.beginFrame();
+  if (!paused) game.sim();
+  game.paint();
+  scene.present({ clear });
+  globalThis.__fiapupFrames = (globalThis.__fiapupFrames || 0) + 1;
+  requestAnimationFrame(frame);
+}
+requestAnimationFrame(frame);
+</script>
+</body>
+</html>
diff --git a/xbox/fiapup/serve.mjs b/xbox/fiapup/serve.mjs
new file mode 100644
index 0000000000..05bb510c98
--- /dev/null
+++ b/xbox/fiapup/serve.mjs
@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// Serve fiapup's working tree for a browser: xbox/fiapup, plus the two scene
+// modules it borrows from xbox/live (the depth-tested WebGL renderer oskiewar
+// uses). Read from disk on every request, so a save is a reload.
+//
+//   node xbox/fiapup/serve.mjs [port]      → http://127.0.0.1:8124
+
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { extname, join, normalize, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = resolve(fileURLToPath(new URL(".", import.meta.url)));
+const live = resolve(here, "../live");
+const port = Number(process.argv[2]) || 8124;
+const borrowed = new Map([
+  ["/live/scene3d-webgl.mjs", join(live, "scene3d-webgl.mjs")],
+  ["/live/scene3d.mjs", join(live, "scene3d.mjs")],
+]);
+const mime = { ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8", ".lisp": "text/plain; charset=utf-8", ".png": "image/png" };
+
+export function fileFor(pathname) {
+  if (pathname === "/" || pathname === "/index.html") return join(here, "index.html");
+  if (borrowed.has(pathname)) return borrowed.get(pathname);
+  const target = normalize(join(here, pathname));
+  return target.startsWith(here + "/") ? target : "";
+}
+
+export function serve(listenPort = port) {
+  const server = createServer(async (request, response) => {
+    const path = fileFor(new URL(request.url, "http://127.0.0.1").pathname);
+    if (!path) { response.writeHead(403); response.end("outside xbox/fiapup"); return; }
+    try {
+      const body = await readFile(path);
+      response.writeHead(200, { "content-type": mime[extname(path)] || "application/octet-stream",
+        "cache-control": "no-store" });
+      response.end(body);
+    } catch (error) {
+      response.writeHead(error.code === "ENOENT" ? 404 : 500);
+      response.end(String(error.message));
+    }
+  });
+  return new Promise((ready) => server.listen(listenPort, "127.0.0.1", () => ready(server)));
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  await serve();
+  console.log(`fiapup → http://127.0.0.1:${port}`);
+  console.log("  WASD/arrows hand · space A · C B (call) · T X (treat) · R Y (play) · or an Xbox pad");
+  console.log("  ?stage=fetch|pet|beg|nap|zoomies|tug[&seconds=n][&pause] to open on a moment");
+}
diff --git a/xbox/fiapup/shots.mjs b/xbox/fiapup/shots.mjs
new file mode 100644
index 0000000000..c1e8df901d
--- /dev/null
+++ b/xbox/fiapup/shots.mjs
@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+// Headless screenshots of the web shell, one per staged moment, into
+// xbox/fiapup/shots/. One browser, closed at the end.
+//
+//   node xbox/fiapup/shots.mjs [moment…]     (default: all of them)
+
+import { mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { serve } from "./serve.mjs";
+
+const here = fileURLToPath(new URL(".", import.meta.url));
+// A worktree has no node_modules of its own; borrow the main checkout's.
+async function puppeteer() {
+  try { return (await import("puppeteer")).default; } catch {}
+  const common = spawnSync("git", ["rev-parse", "--git-common-dir"], { cwd: here, encoding: "utf8" }).stdout.trim();
+  return createRequire(resolve(here, common, "../package.json"))("puppeteer");
+}
+
+const moments = {
+  idle: "", fetch: "stage=fetch&seconds=1.05", pet: "stage=pet&seconds=1.1",
+  rollover: "stage=pet&seconds=3.2", beg: "stage=beg&seconds=2.6", nap: "stage=nap&seconds=9",
+  zoomies: "stage=zoomies&seconds=2.4", tug: "stage=tug&seconds=3.2",
+};
+const wanted = process.argv.slice(2).length ? process.argv.slice(2) : Object.keys(moments);
+const out = resolve(here, "shots");
+mkdirSync(out, { recursive: true });
+
+const server = await serve(8125);
+const browser = await (await puppeteer()).launch({ headless: true,
+  args: ["--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--autoplay-policy=no-user-gesture-required"] });
+try {
+  const page = await browser.newPage();
+  await page.setViewport({ width: 1280, height: 754 });
+  page.on("pageerror", (error) => console.error("page error:", error.message));
+  for (const name of wanted) {
+    await page.goto(`http://127.0.0.1:8125/?pause&${moments[name]}`);
+    await page.waitForFunction(() => (globalThis.__fiapupFrames || 0) > 3, { timeout: 20000 });
+    const state = await page.evaluate(() => globalThis.__fiapup.world.pup.state);
+    const file = resolve(out, `${name}.png`);
+    await page.screenshot({ path: file, clip: { x: 0, y: 0, width: 1280, height: 720 } });
+    console.log(`${name}: pup is ${state} → ${file}`);
+  }
+} finally {
+  await browser.close();
+  server.close();
+}
diff --git a/xbox/fiapup/tests/load.mjs b/xbox/fiapup/tests/load.mjs
new file mode 100644
index 0000000000..569cb61a4b
--- /dev/null
+++ b/xbox/fiapup/tests/load.mjs
@@ -0,0 +1,35 @@
+// Load fiapup.js the way the console does: one script, the host's bindings as
+// its only way out. `host` names the bindings; anything it leaves out is
+// simply not there, as on a host that lacks it.
+
+import { readFileSync } from "node:fs";
+
+export const source = readFileSync(new URL("../fiapup.js", import.meta.url), "utf8");
+
+// The bindings the Xbox host (xbox/native-bios/QuickJsEngine.cpp) gives a
+// piece that fiapup could reach for. Nothing else exists there.
+export const xboxBindings = ["wipe", "synth", "drum", "oscillator", "oscillatorStop", "write",
+  "box", "line", "triangle", "triangle3d", "triangles3d", "runtime", "gamepad", "controllers",
+  "capabilities", "telemetry"];
+
+export function load(host = {}) {
+  const names = [...new Set([...xboxBindings, "frame", ...Object.keys(host)])];
+  const make = new Function(...names, `${source}\nreturn { boot, sim, paint, act, leave, fiapup };`);
+  return make(...names.map((name) => host[name]));
+}
+
+// A host that counts what it is asked to draw, and plays nothing.
+export function countingHost(extra = {}) {
+  const drawn = { faces: 0, texts: [], wipes: 0 };
+  let us = 0;
+  const host = {
+    triangle3d: () => { drawn.faces++; },
+    write: (s) => { drawn.texts.push(s); },
+    wipe: () => { drawn.wipes++; },
+    box: () => {}, line: () => {}, synth: () => {},
+    runtime: () => ({ width: 1920, height: 1080, monotonicUs: (us += 16667) }),
+    gamepad: () => ({ down: [], leftX: 0, leftY: 0 }),
+    ...extra,
+  };
+  return { host, drawn };
+}