@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/vendor/verify/src/page/capture_view.js

@@ -0,0 +1,164 @@
+// Drive the game to a NAMED state through its own hooks and hold it there for
+// the picture (plan m10 `capture_view`, and each view `audit_screens` measures):
+// enter the __FPX_VIEWS__ entry, press the __FPX_VERBS__ asked for in order,
+// let it run for hold_ms, then (freeze) stop the animation loop and CSS
+// animations so the frame taken next is the state read here.
+//
+// Part of @funpixel/verify: one function expression of one argument, loaded by
+// the edge's game tools (include_str!, through funpixel-browser's Evaluate) and
+// by local `funtools capture` / `audit-screens`. See mechanic_check.js for the
+// calling convention.
+//
+// a = { view: string | null, verbs: string[], verb_gap_ms, hold_ms, freeze, safe?, settle_ms? }
+//   view null = only list what is declared. enter() gets 3 s and each verb
+//   1.5 s (a promise past that is left running), so the hosted call stays
+//   inside funpixel-browser's 30 s per call
+//   safe = the phone insets to emulate: absent = the phone's own (a page opened
+//   with funpixel_touch=1: portrait 47/0/34/0, landscape 0/47/21/47 as
+//   top/right/bottom/left, the numbers layout.js is given), false = none
+//   settle_ms = when the page carries the Kapture driver (libs/funpixel-kapture,
+//   the Studio's capture driver), wait up to this long after the hold, before
+//   the freeze, for its settle: two rendered frames with no image or font
+//   loading. Absent or 0 = no wait (the hosted callers pass none)
+//
+// The phone's safe area is EMULATED before the view is entered, for every look
+// but a bare listing (view null, no hold, no freeze): headless Chromium reports
+// every env(safe-area-inset-*) as 0, so a game that pads with env() hugged the
+// edge in the picture while audit-screens measured it against a notch (two
+// games). The page's env(safe-area-inset-*) now resolves to the insets,
+// in its stylesheets, its inline styles and those it adds later, and a resize
+// is sent so a game that reads them again lays out again. capture and
+// audit-screens (local and hosted) share this one emulation.
+//
+// Answers JSON:
+//   declared  — the page has __FPX_VIEWS__
+//   views     — [{ name, motion, moment }] in declaration order (moment: the
+//               view stages a signature moment, HOOKS.md; callers shoot a burst)
+//   view      — the view asked for; entered — its enter() ran and did not throw
+//   verbs     — the verbs pressed; missing — asked for and not declared
+//   state     — __FPX_STATE__() after the hold (null when not declared)
+//   frozen    — the loop was stopped for the picture (held: the clock stands still)
+//   held      — the page runs on the held clock (step_clock.js): every wait
+//               above was that much game time, in fixed frames
+//   safe_area — the insets env(safe-area-inset-*) reports now, or null (none emulated)
+//   settle    — null when not asked or the page has no Kapture driver (not
+//               observed); else { settled, pendingImages, pendingFonts,
+//               rafAlive, errors } — errors the driver trapped since enter()
+//   error     — why it did not enter, or what threw
+async (a) => {
+  // Under the held clock (step_clock.js) every wait here is game time: the clock moves by it.
+  const C = typeof window.__FPX_STEP_CLOCK__ === 'object' && window.__FPX_STEP_CLOCK__ && window.__FPX_STEP_CLOCK__.held === true ? window.__FPX_STEP_CLOCK__ : null;
+  const sleep = C ? (ms) => C.sleep(ms) : (ms) => new Promise((r) => setTimeout(r, ms));
+  const within = C ? (p, ms) => C.within(p, ms) : (p, ms) => Promise.race([Promise.resolve(p), sleep(ms).then(() => undefined)]);
+  const out = { declared: false, views: [], view: a.view ?? null, entered: false, verbs: [], missing: [], state: null, frozen: false, held: !!C, safe_area: null, settle: null, error: '' };
+  const K = a.settle_ms > 0 && typeof window.FunpixelKapture === 'object' && window.FunpixelKapture && typeof window.FunpixelKapture.waitForSettle === 'function' ? window.FunpixelKapture : null;
+
+  const listing = (a.view === null || a.view === undefined) && !a.freeze && !(a.hold_ms > 0);
+  const insets = (() => {
+    if (a.safe === false) return null;
+    const pick = (s) => Object.fromEntries(['top', 'right', 'bottom', 'left'].map((k) => [k, Math.max(0, Number(s[k]) || 0)]));
+    if (a.safe && typeof a.safe === 'object') return pick(a.safe);
+    if (typeof location === 'undefined' || !/[?&]funpixel_touch=1(&|$)/.test(location.search)) return null;
+    return innerHeight >= innerWidth ? { top: 47, right: 0, bottom: 34, left: 0 } : { top: 0, right: 47, bottom: 21, left: 47 };
+  })();
+  const emulate = async (safe) => {
+    const done = window.__FPX_SAFE_AREA__;
+    if (done && ['top', 'right', 'bottom', 'left'].every((k) => done[k] === safe[k])) return;
+    const RE = /env\(\s*safe-area-inset-(top|right|bottom|left)\s*(,[^()]*(\([^()]*\)[^()]*)*)?\)/g;
+    const sub = (t) => String(t).replace(RE, (_, side) => `${(window.__FPX_SAFE_AREA__ || safe)[side]}px`);
+    const has = (t) => typeof t === 'string' && t.includes('safe-area-inset');
+    // Rules and inline styles as they stand…
+    const fix = (style) => { try { if (has(style.cssText)) style.cssText = sub(style.cssText); } catch (e) { /* read-only */ } };
+    const walk = (rules) => { for (const r of rules) { if (r.style) fix(r.style); if (r.cssRules) walk(r.cssRules); } };
+    const sheets = () => { for (const s of document.styleSheets) { try { walk(s.cssRules); } catch (e) { /* another origin's sheet */ } } };
+    const inline = () => { for (const el of document.querySelectorAll('[style*="safe-area-inset"]')) fix(el.style); };
+    // …and those the game writes from now on, as it writes them, so a probe
+    // element it measures at once reads the insets too.
+    const S = CSSStyleDeclaration.prototype;
+    const text = Object.getOwnPropertyDescriptor(S, 'cssText');
+    if (text && text.set && !done) {
+      Object.defineProperty(S, 'cssText', { ...text, set(v) { text.set.call(this, has(v) ? sub(v) : v); } });
+      const setProperty = S.setProperty;
+      S.setProperty = function (p, v, ...rest) { return setProperty.call(this, p, has(v) ? sub(v) : v, ...rest); };
+      const setAttribute = Element.prototype.setAttribute;
+      Element.prototype.setAttribute = function (n, v) { return setAttribute.call(this, n, String(n).toLowerCase() === 'style' && has(v) ? sub(v) : v); };
+      new MutationObserver((list) => {
+        for (const m of list) {
+          if (m.type === 'attributes' && m.target.style) fix(m.target.style);
+          for (const n of m.addedNodes || []) {
+            if (n.nodeName === 'STYLE') sheets();
+            if (n.nodeName === 'LINK') n.addEventListener('load', sheets, { once: true });
+            if (n.nodeType === 1 && n.querySelectorAll) for (const el of n.querySelectorAll('[style*="safe-area-inset"]')) fix(el.style);
+          }
+        }
+      }).observe(document.documentElement, { subtree: true, childList: true, attributes: true, attributeFilter: ['style'] });
+    }
+    window.__FPX_SAFE_AREA__ = { ...safe };
+    sheets();
+    inline();
+    dispatchEvent(new Event('resize'));
+    await within(new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r))), 200);
+  };
+  if (insets && !listing) {
+    try { await emulate(insets); out.safe_area = insets; } catch (e) { /* the look goes on without it */ }
+  }
+  const v = window.__FPX_VIEWS__;
+  if (v && typeof v === 'object') {
+    out.declared = true;
+    out.views = Object.keys(v).map((name) => ({ name, motion: !!(v[name] && v[name].motion === true), moment: !!(v[name] && v[name].moment === true) }));
+  }
+  if (a.view === null || a.view === undefined) return JSON.stringify(out);
+  if (!out.declared) { out.error = 'the page declares no __FPX_VIEWS__'; return JSON.stringify(out); }
+  const entry = v[a.view];
+  if (!entry || typeof entry.enter !== 'function') {
+    out.error = `no view "${a.view}" (declared: ${out.views.map((x) => x.name).join(', ') || 'none'})`;
+    return JSON.stringify(out);
+  }
+  if (K) { try { K.beginView(a.view); } catch (e) { /* the errors stay the boot's */ } }
+  try {
+    await within(entry.enter(), 3000);
+    out.entered = true;
+  } catch (e) {
+    out.error = `enter() threw: ${String(e && e.message || e)}`;
+    return JSON.stringify(out);
+  }
+  const verbs = window.__FPX_VERBS__ || {};
+  for (const name of Array.isArray(a.verbs) ? a.verbs : []) {
+    if (typeof verbs[name] !== 'function') { out.missing.push(name); continue; }
+    try {
+      await within(verbs[name](), 1500);
+      out.verbs.push(name);
+    } catch (e) {
+      out.error = `verb ${name} threw: ${String(e && e.message || e)}`;
+      break;
+    }
+    await sleep(a.verb_gap_ms ?? 150);
+  }
+  await sleep(Math.max(0, a.hold_ms ?? 600));
+  if (typeof window.__FPX_STATE__ === 'function') {
+    try {
+      const s = JSON.stringify(window.__FPX_STATE__());
+      out.state = s && s.length <= 4000 ? JSON.parse(s) : { truncated: true, json: String(s).slice(0, 4000) };
+    } catch (e) { out.state = null; }
+  }
+  if (K) {
+    // Before the freeze: the settle waits on rendered frames, which the freeze stops.
+    try {
+      const settled = await within(K.waitForSettle(a.settle_ms), a.settle_ms + 250);
+      const snap = K.snapshot(K.currentErrors());
+      out.settle = { settled: settled === true, pendingImages: snap.pendingImages, pendingFonts: snap.pendingFonts, rafAlive: snap.rafAlive, errors: snap.errors };
+    } catch (e) { out.settle = null; }
+  }
+  if (a.freeze && C) {
+    // Held: nothing moves until the caller advances the clock, which a burst or a later look may.
+    out.frozen = true;
+  } else if (a.freeze) {
+    // The last frame drawn stays on screen; nothing after this moves it.
+    window.requestAnimationFrame = () => 0;
+    try { for (const an of document.getAnimations()) an.pause(); } catch (e) { /* older engines */ }
+    for (const m of document.querySelectorAll('video')) { try { m.pause(); } catch (e) { /* ignore */ } }
+    await sleep(50);
+    out.frozen = true;
+  }
+  return JSON.stringify(out);
+}

package/dist/vendor/verify/src/page/context_loss_listener.js

@@ -0,0 +1,23 @@
+// Install a webglcontextlost listener BEFORE any check runs: the event fires once
+// and does not replay, so a late listener reports a lost context as fine.
+//
+// Part of @funpixel/verify: one function expression of one argument, loaded by
+// funpixel-browser (include_str!) and by local `funtools verify`. See
+// mechanic_check.js for the calling convention.
+(a) => {
+  try {
+    if (window.__FPX_CTXLOST__ === undefined) window.__FPX_CTXLOST__ = false;
+    if (window.__FPX_CTXWATCH__) return 'already';
+    const mark = () => { window.__FPX_CTXLOST__ = true; };
+    // Both spellings: WebGL fires webglcontextlost, WebGPU's device
+    // exposes a lost promise instead, and a canvas added later needs the
+    // document-level capture to catch it.
+    document.addEventListener('webglcontextlost', mark, true);
+    for (const c of document.querySelectorAll('canvas')) {
+      c.addEventListener('webglcontextlost', mark, false);
+    }
+    window.__FPX_CTXWATCH__ = true;
+    return 'installed';
+  } catch (e) { return 'failed'; }
+}
+

package/dist/vendor/verify/src/page/dressing.js

@@ -0,0 +1,106 @@
+// How dressed is the play (lane V2, the Silt bar's S7: "dressing density with a clear road"; Silt's
+// chapter one carries 42k instanced flowers, two of our games "read as shapes"): the small things of a
+// Three scene counted per area round the player, by role, beside what they cost a frame.
+//
+// A thing is one instance of an InstancedMesh, or a mesh that is small (footprint under `max_size`,
+// default 6 m) and not the terrain, a backdrop, the player or a see-through glow. Its role is the mesh's
+// userData.role, else the middle word of a `dress-<role>-<kind>` name (the 3D starter's dressing.ts), else
+// "prop". Counted inside `radius` metres (default 15) of the player on the ground plane (the player node
+// by `player` name, else the state's hero, else the camera's look point): things per 100 m² of that disc.
+// Roads (state.world.roads: [{ pts: [[x, z]…], width }]) are read when the game declares them: a thing on
+// one is counted (`on_road`: dressing only, a pickup or a platform on the road is play; the road stays clear). The frame's cost is renderer.info's last frame
+// (draw calls, triangles) when the renderer is exposed, and the scene's instanced triangles either way.
+//
+// Part of @funpixel/verify: one function expression of one argument. See mechanic_check.js for the
+// calling convention.
+//
+// a = { radius (m, 15), max_size (m, 6), player (regex source, 'player|hero') }
+//
+// Answers JSON:
+//   engine — three | none;  error
+//   at — { x, z, from: player|state|camera } the disc's centre;  radius;  area (m²)
+//   things — counted in the disc;  per100 — things per 100 m²;  by_role — { role: per 100 m² }
+//   kinds — [{ name, role, count (in the disc), instances (all), triangles (one instance) }], the 12 biggest
+//   on_road — things on a declared road (null: no road declared);  roads — how many
+//   instanced — instances in the scene;  instanced_triangles — their triangles together
+//   calls, triangles — renderer.info's last frame (null when the renderer is not exposed)
+//   target — state.world.dressing.target when the game states one (things per 100 m²), else null
+(a) => {
+  const out = { engine: 'none', error: '', at: null, radius: 0, area: 0, things: 0, per100: 0, by_role: {}, kinds: [], on_road: null, roads: 0, instanced: 0, instanced_triangles: 0, calls: null, triangles: null, target: null };
+  const scene = window.__THREEJS_SCENE__ || (window.scene && window.scene.isScene ? window.scene : null);
+  if (!scene || !scene.isObject3D) { out.error = 'no Three scene (window.__THREEJS_SCENE__)'; return JSON.stringify(out); }
+  out.engine = 'three';
+  const R = a.radius || 15, MAX = a.max_size || 6, PLAYER = new RegExp(a.player || 'player|hero', 'i');
+  const SKIP = /^(ground|terrain|floor|sky|backdrop|horizon|skybox|dome|water|sea|ocean)$|^(ground|terrain|sky)[-_]/i;
+  let state = null;
+  try { state = typeof window.__FPX_STATE__ === 'function' ? window.__FPX_STATE__() : null; } catch { state = null; }
+  scene.updateMatrixWorld && scene.updateMatrixWorld();
+  const V = scene.position.constructor;
+  // The disc's centre: the player node, else the state's hero, else where the camera looks.
+  let at = null, player = null;
+  scene.traverse((o) => { if (!player && o.name && PLAYER.test(o.name) && o.visible !== false) player = o; });
+  // Positions straight from the world matrices (column 3), so a scene graph without helpers reads too.
+  const posOf = (o) => { const e = o.matrixWorld.elements; return { x: e[12], z: e[14] }; };
+  if (player) { const q = posOf(player); at = { x: q.x, z: q.z, from: 'player' }; }
+  else if (state && state.hero && typeof state.hero.x === 'number') at = { x: state.hero.x, z: state.hero.z ?? 0, from: 'state' };
+  else {
+    const cam = window.__THREEJS_CAMERA__ || window.camera;
+    if (cam && cam.isCamera && cam.matrixWorld) {
+      const e = cam.matrixWorld.elements, d = { x: -e[8], y: -e[9], z: -e[10] }, t = d.y < -0.05 ? -e[13] / d.y : 10;
+      at = { x: e[12] + d.x * t, z: e[14] + d.z * t, from: 'camera' };
+    }
+  }
+  if (!at) { out.error = 'no player, hero or camera to centre on'; return JSON.stringify(out); }
+  const roads = Array.isArray(state?.world?.roads) ? state.world.roads.filter((r) => r && Array.isArray(r.pts) && r.pts.length >= 2) : [];
+  out.roads = roads.length; if (roads.length) out.on_road = 0;
+  const onRoad = (x, z) => roads.some((r) => {
+    for (let i = 1; i < r.pts.length; i++) {
+      const [ax, az] = r.pts[i - 1], [bx, bz] = r.pts[i], dx = bx - ax, dz = bz - az, l = dx * dx + dz * dz || 1, t = Math.max(0, Math.min(1, ((x - ax) * dx + (z - az) * dz) / l));
+      if (Math.hypot(x - ax - t * dx, z - az - t * dz) < (r.width || 0) / 2) return true;
+    }
+    return false;
+  });
+  const roleOf = (o) => (o.userData && typeof o.userData.role === 'string' ? o.userData.role : (/^dress-([a-z]+)-/.exec(o.name || '') || [])[1] || 'prop');
+  const trisOf = (g) => (g ? (g.index ? g.index.count : g.attributes && g.attributes.position ? g.attributes.position.count : 0) / 3 : 0);
+  const under = (o) => { for (let p = o; p; p = p.parent) if (p === player) return true; return false; };
+  const counts = {}, kinds = new Map();
+  let n = 0;
+  const count = (o, x, z) => {
+    if (Math.hypot(x - at.x, z - at.z) > R) return false;
+    n++; const role = roleOf(o); counts[role] = (counts[role] || 0) + 1;
+    if (roads.length && role !== 'prop' && onRoad(x, z)) out.on_road++; // dressing on the road; a pickup or a platform on it is play
+    return true;
+  };
+  scene.traverse((o) => {
+    if (!o.isMesh || o.visible === false || SKIP.test(o.name || '') || under(o)) return;
+    const mat = Array.isArray(o.material) ? o.material[0] : o.material;
+    if (mat && mat.transparent && mat.opacity < 0.5 && !mat.map) return;
+    const g = o.geometry, tris = trisOf(g), key = o.name || o.type;
+    if (o.isInstancedMesh) {
+      const k = kinds.get(key) || { name: key, role: roleOf(o), count: 0, instances: 0, triangles: tris };
+      out.instanced += o.count; out.instanced_triangles += o.count * tris; k.instances += o.count;
+      const arr = o.instanceMatrix && o.instanceMatrix.array;
+      for (let i = 0; arr && i < o.count; i++) { const w = new V(arr[i * 16 + 12], arr[i * 16 + 13], arr[i * 16 + 14]).applyMatrix4(o.matrixWorld); if (count(o, w.x, w.z)) k.count++; }
+      kinds.set(key, k);
+      return;
+    }
+    if (!g) return;
+    if (!g.boundingBox && g.computeBoundingBox) g.computeBoundingBox();
+    const b = g.boundingBox, e = o.matrixWorld.elements, sx = Math.hypot(e[0], e[1], e[2]), sz = Math.hypot(e[8], e[9], e[10]);
+    if (!b || Math.max((b.max.x - b.min.x) * sx, (b.max.z - b.min.z) * sz) > MAX) return;
+    const p = posOf(o);
+    const k = kinds.get(key) || { name: key, role: roleOf(o), count: 0, instances: 0, triangles: tris };
+    k.instances++; if (count(o, p.x, p.z)) k.count++; kinds.set(key, k);
+  });
+  const area = Math.PI * R * R, r1 = (v) => Math.round(v * 10) / 10;
+  out.at = { x: r1(at.x), z: r1(at.z), from: at.from }; out.radius = R; out.area = Math.round(area);
+  out.things = n; out.per100 = r1((n / area) * 100);
+  out.by_role = Object.fromEntries(Object.entries(counts).map(([k, v]) => [k, r1((v / area) * 100)]));
+  out.kinds = [...kinds.values()].sort((x, y) => y.instances - x.instances).slice(0, 12).map((k) => ({ ...k, triangles: Math.round(k.triangles) }));
+  out.instanced_triangles = Math.round(out.instanced_triangles);
+  const r = window.__THREEJS_RENDERER__;
+  if (r && r.info && r.info.render) { out.calls = r.info.render.calls; out.triangles = r.info.render.triangles; }
+  const tg = state && state.world && state.world.dressing ? state.world.dressing.target : null;
+  out.target = typeof tg === 'number' ? tg : null;
+  return JSON.stringify(out);
+}

package/dist/vendor/verify/src/page/enter_view.js

@@ -0,0 +1,33 @@
+// Enter the declared gameplay view: the __FPX_VIEWS__ entry marked motion: true,
+// else 'playing', else the first that is not a title/menu screen. Returns
+// 'ok:<view>', 'no-map', 'no-view' or 'threw:<error>'.
+//
+// a = { seed? } — a whole number set as window.__FPX_SEED__ first, unless the
+// page already has one (a journey's or the game's own): verify re-enters play
+// before every check, and a game that seeds its rounds from __FPX_SEED__ (the
+// scaffold's rules.ts) then starts each from a known round, not a random one.
+//
+// Part of @funpixel/verify: one function expression of one argument, loaded by
+// funpixel-browser (include_str!) and by local `funtools verify`. See
+// mechanic_check.js for the calling convention.
+              (a) => {
+try {
+if (a && Number.isInteger(a.seed) && typeof window.__FPX_SEED__ !== 'number') window.__FPX_SEED__ = a.seed;
+const v = window.__FPX_VIEWS__;
+if (!v) return "no-map";
+const keys = Object.keys(v);
+// The gameplay screen is the one that ANIMATES.
+let pick = keys.find(k => v[k] && v[k].motion === true);
+// Fallbacks: the conventional name, then the first entry that
+// is not a title/menu screen.
+if (!pick && v.playing) pick = "playing";
+if (!pick) pick = keys.find(k => !/title|menu|intro|splash/i.test(k));
+if (!pick) return "no-view";
+const entry = v[pick];
+if (!entry || typeof entry.enter !== 'function') return "no-view";
+entry.enter();
+return "ok:" + pick;
+} catch (e) {
+return "threw:" + String(e);
+}
+}

package/dist/vendor/verify/src/page/feel.js

@@ -0,0 +1,126 @@
+// The feel trace (research 18's craft properties 1, 2, 4, 7): every animation frame while a
+// script plays, the game's own __FPX_STATE__ (only the fields the feel measures read) and, for
+// each actor the state names, a short key of what it looks like — its pictures (texture or sheet
+// frame), which of its parts are shown, its tint, and its pose in coarse steps (a squash or a
+// topple changes the key; a breath, a lean or a facing flip does not). funtools judges the trace
+// (src/feel/judge.ts): the verb's real numbers against the design's, tell to strike, the death
+// beat and the restart, and whether each actor looks different in each of its states. Read-only.
+//
+// a = { op: 'install' | 'input' | 'drain', label?, player?, max? }
+//   install — start the recorder (rAF); forgets an earlier trace
+//   input   — note an input the script is about to play, with the page clock
+//   drain   — stop and return { observed, samples: [{ t, s, v }], inputs: [{ t, label }], names }
+//             s = the state's feel fields; v = { actorName: key } for the actors found
+//
+// State fields read (all optional, the game's words): t (the game's own clock, seconds), screen,
+// control, dead, hits, lives, score, hero { x, y, vx, body, unit, grounded, state, invulnerable },
+// threats [{ id, kind, phase }], actors { nodeName: stateName }, juice { name: number } (up to 8: the
+// numbers the renderer applies — shake, flash, squash, particles — so a key event's answer is timed). A game that exposes none is "not measured", never a pass.
+//
+// Part of @funpixel/verify: one function expression of one argument. Pixi (v7, v8) and Three.
+(a) => {
+  const w = window;
+  if (a && a.op === 'input') {
+    const r = w.__FPX_FEEL__;
+    if (r) r.inputs.push({ t: performance.now(), label: String(a.label || '').slice(0, 60) });
+    return r ? 'noted' : 'not installed';
+  }
+  if (a && a.op === 'drain') {
+    const r = w.__FPX_FEEL__;
+    if (!r) return JSON.stringify({ observed: false, samples: [], inputs: [], names: [] });
+    r.stop = true;
+    return JSON.stringify({ observed: r.samples.some((x) => x.s !== null), samples: r.samples, inputs: r.inputs, names: r.names.slice(0, 40) });
+  }
+  if (w.__FPX_FEEL__) w.__FPX_FEEL__.stop = true;
+  const MAX = (a && a.max) || 7200;
+  const player = new RegExp((a && a.player) || 'player|hero|avatar', 'i');
+  const rec = { stop: false, samples: [], inputs: [], names: [] };
+  w.__FPX_FEEL__ = rec;
+  const seen = new Set();
+  const PICK = ['t', 'screen', 'control', 'dead', 'hits', 'lives', 'score'];
+  const HERO = ['x', 'y', 'vx', 'vy', 'body', 'unit', 'grounded', 'state', 'invulnerable'];
+  const plain = (v) => v === null || ['number', 'boolean', 'string'].includes(typeof v);
+  const pick = (raw) => {
+    if (!raw || typeof raw !== 'object') return null;
+    const s = {};
+    for (const k of PICK) if (plain(raw[k])) s[k] = raw[k];
+    if (raw.hero && typeof raw.hero === 'object') {
+      s.hero = {};
+      for (const k of HERO) if (plain(raw.hero[k])) s.hero[k] = raw.hero[k];
+    }
+    if (Array.isArray(raw.threats)) {
+      s.threats = raw.threats.slice(0, 16).map((t, i) => ({ id: String(t && t.id !== undefined ? t.id : i), kind: t && t.kind ? String(t.kind) : undefined, phase: t && t.phase !== undefined ? String(t.phase) : undefined }));
+    }
+    if (raw.juice && typeof raw.juice === 'object') {
+      s.juice = {};
+      for (const [k, v] of Object.entries(raw.juice).slice(0, 8)) if (typeof v === 'number' && isFinite(v)) s.juice[k] = Math.round(v * 1000) / 1000;
+    }
+    if (raw.actors && typeof raw.actors === 'object') {
+      s.actors = {};
+      for (const [k, v] of Object.entries(raw.actors).slice(0, 16)) if (plain(v)) s.actors[k] = String(v);
+    }
+    return s;
+  };
+  const read = () => { try { return pick(w.__FPX_STATE__ ? w.__FPX_STATE__() : null); } catch (e) { return null; } };
+
+  const app = w.__PIXI_APP__ || (w.__PIXI_DEVTOOLS__ && w.__PIXI_DEVTOOLS__.app) || null;
+  const root = (app && app.stage) || w.__PIXI_STAGE__ || w.__THREEJS_SCENE__ || (w.scene && w.scene.isScene ? w.scene : null);
+  const pixi = !!(root && !root.isObject3D && Array.isArray(root.children));
+  // Coarse steps: a squash of 20% or more, a turn of 45° or more, a fade by a quarter change the key.
+  const step = (x, by) => Math.round(x / by);
+  const hash = (str) => { let h = 5381; for (let i = 0; i < str.length; i++) h = ((h * 33) ^ str.charCodeAt(i)) >>> 0; return h.toString(36); };
+  const look = (o) => {
+    if (pixi) {
+      const t = o.texture, f = (t && t.frame) || {};
+      const pic = t ? `${t.uid ?? t.label ?? (t.baseTexture && t.baseTexture.uid) ?? ''}:${f.x},${f.y},${f.width},${f.height}` : '';
+      const sx = Math.abs(o.scale ? o.scale.x : 1) || 1e-6, sy = Math.abs(o.scale ? o.scale.y : 1) || 1e-6;
+      return `${pic}/${o.tint ?? ''}/${step(Math.log(sy / sx), 0.2)}/${step(o.rotation || 0, Math.PI / 4)}/${step(o.alpha ?? 1, 0.25)}`;
+    }
+    const m = o.material && !Array.isArray(o.material) ? o.material : null;
+    const pic = m && m.map ? `${m.map.uuid}:${m.map.offset ? `${m.map.offset.x},${m.map.offset.y}` : ''}` : '';
+    const col = m && m.color ? m.color.getHex() : '', em = m && m.emissive ? step(m.emissive.r + m.emissive.g + m.emissive.b, 0.5) : '';
+    const s = o.scale || { x: 1, y: 1 }, r = o.rotation || { x: 0, y: 0, z: 0 };
+    return `${pic}/${col}/${em}/${step(Math.log((Math.abs(s.y) || 1e-6) / (Math.abs(s.x) || 1e-6)), 0.2)}/${step(r.x, Math.PI / 4)},${step(r.z, Math.PI / 4)}/${m ? step(m.opacity ?? 1, 0.25) : ''}`;
+  };
+  // An actor's key: its own look and every shown part under it (a part hidden or shown is a pose).
+  const keyOf = (o) => {
+    const parts = [look(o)];
+    const walk = (n, depth, path) => {
+      if (depth > 4) return;
+      (n.children || []).forEach((c, i) => {
+        if (c.visible === false || (pixi && (c.alpha ?? 1) <= 0.01)) return;
+        parts.push(`${path}${i}:${look(c)}`);
+        walk(c, depth + 1, `${path}${i}.`);
+      });
+    };
+    walk(o, 0, '');
+    return hash(parts.join('|'));
+  };
+  const find = (wanted) => {
+    const out = {};
+    if (!root) return out;
+    const walk = (o, depth) => {
+      if (depth > 12) return;
+      const name = o.label || o.name || '';
+      if (name && !seen.has(name) && seen.size < 40) { seen.add(name); rec.names.push(name); }
+      if (name && wanted.has(name) && !(name in out) && o.visible !== false) out[name] = keyOf(o);
+      for (const c of o.children || []) walk(c, depth + 1);
+    };
+    walk(root, 0);
+    return out;
+  };
+  const tick = () => {
+    if (rec.stop) return;
+    const s = read();
+    const wanted = new Set(s && s.actors ? Object.keys(s.actors) : []);
+    // The hero's state stands for the player node when the game names no actors.
+    if (s && s.hero && s.hero.state !== undefined && !wanted.size) for (const n of seen) if (player.test(n)) wanted.add(n);
+    rec.samples.push({ t: Math.round(performance.now() * 10) / 10, s, v: find(wanted) });
+    if (rec.samples.length >= MAX) { rec.stop = true; return; }
+    requestAnimationFrame(tick);
+  };
+  // One walk to learn the names, so the hero's node is known from the first frame.
+  find(new Set());
+  requestAnimationFrame(tick);
+  return 'installed';
+}

package/dist/vendor/verify/src/page/feel_sweep.js

@@ -0,0 +1,75 @@
+// One timed attempt of a forgiveness sweep (funtools feel: coyote time, jump buffer). The page
+// watches __FPX_STATE__ every animation frame on the game's own clock (state `t` in seconds when
+// the game gives one, else the page's) and presses a key at an exact offset from a moment:
+//
+//   after  (offset_ms >= 0): the anchor turning true (it was false first), then the press offset_ms
+//          later — "jump 60 ms after leaving the ledge"
+//   before (offset_ms < 0):  the cue key pressed at arming, then the press at cue + lead_ms + offset_ms,
+//          where lead_ms is the anchor's delay after the cue, calibrated by an attempt with no press
+//          ("jump 60 ms before landing")
+//
+// then reads whether `success` held within within_ms after both the press and the anchor. Keys are
+// dispatched as KeyboardEvents on the focused element (untrusted: a game that checks isTrusted
+// ignores them). Bounded by timeout_ms. Read-only apart from the keys.
+//
+// a = { cue?: code, anchor: { field, op, value }, press?: code (none = calibrate), offset_ms, lead_ms?,
+//       success: { field, op, value }, within_ms, timeout_ms }
+// → { clock: 'game' | 'page', cue_t, anchor_t, press_t, success: bool | null, why? }  (times in ms)
+//
+// Part of @funpixel/verify: one function expression of one argument.
+(a) => new Promise((done) => {
+  const w = window;
+  const KEY = { Space: ' ', Enter: 'Enter', Escape: 'Escape', ArrowUp: 'ArrowUp', ArrowDown: 'ArrowDown', ArrowLeft: 'ArrowLeft', ArrowRight: 'ArrowRight' };
+  const keyOf = (code) => KEY[code] || (/^Key[A-Z]$/.test(code) ? code.slice(3).toLowerCase() : /^Digit\d$/.test(code) ? code.slice(5) : code);
+  const press = (code) => {
+    const el = document.activeElement && document.activeElement !== document.documentElement ? document.activeElement : document.body;
+    const init = { code, key: keyOf(code), bubbles: true, cancelable: true };
+    el.dispatchEvent(new KeyboardEvent('keydown', init));
+    setTimeout(() => el.dispatchEvent(new KeyboardEvent('keyup', init)), 60);
+  };
+  const read = () => { try { return w.__FPX_STATE__ ? w.__FPX_STATE__() : null; } catch (e) { return null; } };
+  const field = (s, path) => String(path).split('.').reduce((o, k) => (o === null || o === undefined ? undefined : o[k]), s);
+  const holds = (s, e) => {
+    const v = field(s, e.field), x = e.value;
+    if (v === undefined) return false;
+    if (e.op === '=') return String(v) === String(x);
+    if (e.op === '!=') return String(v) !== String(x);
+    const n = Number(v), m = Number(x);
+    return e.op === '>' ? n > m : e.op === '<' ? n < m : e.op === '>=' ? n >= m : n <= m;
+  };
+  let clock = null;
+  const now = (s) => {
+    const g = s && typeof s.t === 'number' && Number.isFinite(s.t) ? s.t * 1000 : null;
+    if (clock === null) clock = g === null ? 'page' : 'game';
+    return clock === 'game' && g !== null ? g : performance.now();
+  };
+  const r = { clock: null, cue_t: null, anchor_t: null, press_t: null, success: null };
+  const started = performance.now();
+  let sawFalse = false;
+  const finish = (why) => { r.clock = clock; if (why) r.why = why; done(JSON.stringify(r)); };
+  const frame = () => {
+    const s = read();
+    const t = now(s);
+    if (a.cue && r.cue_t === null) { press(a.cue); r.cue_t = t; return requestAnimationFrame(frame); }
+    if (s) {
+      const on = holds(s, a.anchor);
+      if (!on) sawFalse = true;
+      else if (sawFalse && r.anchor_t === null) r.anchor_t = t;
+    }
+    if (!a.press && r.anchor_t !== null) return finish(); // calibration: the anchor's time is the answer
+    if (a.press && r.press_t === null) {
+      const due = a.offset_ms >= 0
+        ? (r.anchor_t !== null ? r.anchor_t + a.offset_ms : null)
+        : (r.cue_t !== null && typeof a.lead_ms === 'number' ? r.cue_t + a.lead_ms + a.offset_ms : null);
+      if (due !== null && t >= due - 0.5) { press(a.press); r.press_t = t; }
+    }
+    const from = r.anchor_t !== null && (!a.press || r.press_t !== null) ? Math.max(r.anchor_t, r.press_t ?? r.anchor_t) : null;
+    if (from !== null && t > from) {
+      if (s && holds(s, a.success)) { r.success = true; return finish(); }
+      if (t - from > a.within_ms) { r.success = false; return finish(); }
+    }
+    if (performance.now() - started > a.timeout_ms) return finish(r.anchor_t === null ? 'the anchor never turned true' : 'timed out');
+    requestAnimationFrame(frame);
+  };
+  requestAnimationFrame(frame);
+})

package/dist/vendor/verify/src/page/first_paint.js

@@ -0,0 +1,54 @@
+// Wait for the first painted frame (~3 s budget): resolves the instant the largest
+// canvas shows more than a flat clear colour. Returns 'painted', 'webgl-settle'
+// (readback refused), 'no-canvas' or 'timeout'.
+//
+// Part of @funpixel/verify: one function expression of one argument, loaded by
+// funpixel-browser (include_str!) and by local `funtools verify`. See
+// mechanic_check.js for the calling convention.
+async (a) => {
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+  const raf = () => new Promise(r => requestAnimationFrame(r));
+  const pickCanvas = () => {
+    let best = null, area = 0;
+    for (const c of document.querySelectorAll('canvas')) {
+      const a = c.width * c.height;
+      if (a > area) { area = a; best = c; }
+    }
+    return best;
+  };
+  // Non-canvas (pure HTML/CSS) games: just give one frame + a beat.
+  const c0 = pickCanvas();
+  if (!c0) { await raf(); await sleep(150); return 'no-canvas'; }
+  const looksPainted = (canvas) => {
+    try {
+      const w = 64, h = 64;
+      const off = document.createElement('canvas');
+      off.width = w; off.height = h;
+      const ctx = off.getContext('2d');
+      ctx.drawImage(canvas, 0, 0, w, h);
+      const d = ctx.getImageData(0, 0, w, h).data;
+      // Non-uniform = the engine drew past a flat clear color.
+      const r0 = d[0], g0 = d[1], b0 = d[2];
+      for (let i = 4; i < d.length; i += 4) {
+        if (Math.abs(d[i]-r0) > 6 || Math.abs(d[i+1]-g0) > 6 || Math.abs(d[i+2]-b0) > 6) {
+          return true;
+        }
+      }
+      return false;
+    } catch (e) {
+      // WebGL canvas readback can taint/throw — treat as painted
+      // after a short settle rather than blocking the whole budget.
+      return null;
+    }
+  };
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    const canvas = pickCanvas();
+    const verdict = canvas ? looksPainted(canvas) : false;
+    if (verdict === true) { await raf(); return 'painted'; }
+    if (verdict === null) { await sleep(400); return 'webgl-settle'; }
+    await raf();
+  }
+  return 'timeout';
+}
+

package/dist/vendor/verify/src/page/fonts.js

@@ -0,0 +1,50 @@
+// Do the game's fonts load? The families checked are the PLANNED ones
+// (funpixel.json metadata.font / fonts, the Plan's theme font) or, when none
+// is planned, every family the page's @font-face rules declare. Each is asked
+// for with document.fonts.load(), so a font the current screen has not used
+// yet still counts, and one whose file 404s or will not decode fails.
+// a = { planned: [family…], timeout_ms }
+// Returns JSON { observed, planned, fonts: [{ family, source, status, used }] }:
+//   source 'face' (an @font-face declares it) | 'system' (none, but a web-safe
+//   family every device has) | 'none';
+//   status 'loaded' | 'error' (the file failed) | 'missing' (planned, never
+//   declared: every player sees a fallback) | 'system' | 'timeout' — the last
+//   two are not observed, never a failure;
+//   used = it had already loaded before the probe asked (the page drew with it).
+//
+// Part of @funpixel/verify: one function expression of one argument, loaded by
+// funpixel-browser (include_str!) and by local `funtools verify`. See
+// mechanic_check.js for the calling convention.
+async (a) => {
+  const GENERIC = /^(serif|sans-serif|monospace|cursive|fantasy|system-ui|ui-[a-z-]+|emoji|math|fangsong|inherit|initial|unset)$/i;
+  const WEB_SAFE = /^(arial|helvetica|helvetica neue|times|times new roman|georgia|verdana|tahoma|trebuchet ms|courier|courier new|impact|segoe ui|-apple-system|blinkmacsystemfont)$/i;
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+  const clean = (f) => String(f || '').trim().replace(/^['"]+|['"]+$/g, '').trim();
+  const set = document.fonts;
+  if (!set) return JSON.stringify({ observed: false, planned: [], fonts: [] });
+  const planned = [...new Set((a.planned || []).map(clean).filter((f) => f && !GENERIC.test(f)))];
+  const faces = Array.from(set);
+  const declared = [...new Set(faces.map((f) => clean(f.family)).filter(Boolean))].sort();
+  const targets = (planned.length ? planned : declared).slice(0, 8);
+  if (!targets.length) return JSON.stringify({ observed: false, planned, fonts: [] });
+  await Promise.race([set.ready, sleep(a.timeout_ms)]);
+  const fonts = [];
+  for (const family of targets) {
+    const mine = faces.filter((f) => clean(f.family).toLowerCase() === family.toLowerCase());
+    if (!mine.length) {
+      const system = WEB_SAFE.test(family);
+      fonts.push({ family, source: system ? 'system' : 'none', status: system ? 'system' : 'missing', used: false });
+      continue;
+    }
+    const used = mine.some((f) => f.status === 'loaded');
+    let status = 'loaded';
+    if (!used) {
+      try {
+        const got = await Promise.race([set.load('16px "' + family.replace(/"/g, '') + '"'), sleep(a.timeout_ms).then(() => 'timeout')]);
+        status = got === 'timeout' ? 'timeout' : mine.some((f) => f.status === 'loaded') ? 'loaded' : 'error';
+      } catch (e) { status = 'error'; }
+    }
+    fonts.push({ family, source: 'face', status, used });
+  }
+  return JSON.stringify({ observed: true, planned, fonts });
+}