@funpixel/tools 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,164 @@
+// One act of the hosted blind player (Tools API `play`): the steps a player
+// asked for, played as input on the running game, with the game's clock held
+// between acts (the player model thinks for seconds between screens; a game
+// left running meanwhile kills an idle player). The same hold as local
+// `funtools play` (libs/funpixel-tools/src/play/clock.ts): rAF, timers,
+// performance.now and Date.now are wrapped; while held, frames and timers that
+// fall due wait and the clock the game reads skips the held time. Installed on
+// the first call, after the game's own scripts: a loop that asks for its next
+// frame through window.requestAnimationFrame (every engine's ticker) is held;
+// a timer armed before that is not.
+//
+// The browser's page is SHARED behind a mutex, so the caller holds it only for
+// one act at a time. `nonce` marks the page this round loaded: an act that
+// finds another nonce (another caller navigated in between) plays nothing and
+// answers `lost`, and the caller reloads and replays its log.
+//
+// Input is synthetic: pointer events (touch pointers on a phone, with touch
+// events beside them; mouse events and a click on a desktop) on the element
+// under the point, and key events on the focused element (they bubble to the
+// document and the window). A game that insists on trusted events does not
+// answer them; the report says what the screen showed.
+//
+// Part of @funpixel/verify: one function expression of one argument. See
+// mechanic_check.js for the calling convention.
+//
+// a = { nonce, load: bool, touch: bool, steps: [
+//         { kind: 'tap', x, y } | { kind: 'drag', x1, y1, x2, y2, ms }
+//       | { kind: 'hold_at', x, y, ms } | { kind: 'hold_key', key, ms }
+//       | { kind: 'press', key, times } | { kind: 'wait', ms } ] }
+//   coordinates are CSS pixels; `load` marks a freshly loaded page as this
+//   round's (and installs the clock); the caller keeps an act's waits well
+//   under the browser's 30 s per call.
+//
+// Answers JSON: { lost, played, results: [{ ok, error }], errors: [page errors
+// seen during the act], size: { w, h } }
+async (a) => {
+  const out = { lost: false, played: 0, results: [], errors: [], size: { w: innerWidth, h: innerHeight } };
+  if (a.load) {
+    window.__FPX_PLAY_NONCE__ = a.nonce;
+    if (!window.__FPX_PLAY_CLOCK__) {
+      const perfNow = performance.now.bind(performance), dateNow = Date.now.bind(Date);
+      const raf = window.requestAnimationFrame.bind(window), caf = window.cancelAnimationFrame.bind(window);
+      const st = window.setTimeout.bind(window), si = window.setInterval.bind(window);
+      let paused = false, pausedAt = 0, offset = 0, next = 1;
+      const frames = new Map(), held = [];
+      performance.now = () => (paused ? pausedAt : perfNow()) - offset;
+      Date.now = () => Math.round(dateNow() - offset - (paused ? perfNow() - pausedAt : 0));
+      // Only what the game asked for before the hold is held. A frame or a timer
+      // asked for while held is the browser driver's own (it waits a frame for
+      // the page to settle after each call): held, it would never answer.
+      const frame = (id, cb, free) => raf((t) => {
+        if (!frames.has(id)) return;
+        if (paused && !free) { frames.set(id, frame(id, cb, free)); return; }
+        frames.delete(id);
+        cb(t - offset);
+      });
+      window.requestAnimationFrame = (cb) => { const id = next++; frames.set(id, frame(id, cb, paused)); return id; };
+      window.cancelAnimationFrame = (id) => { const n = frames.get(id); if (n !== undefined) caf(n); frames.delete(id); };
+      const later = (fn, args) => { const free = paused; return () => { if (paused && !free) held.push(() => fn(...args)); else fn(...args); }; };
+      window.setTimeout = (fn, ms, ...args) => (typeof fn === 'function' ? st(later(fn, args), ms) : st(fn, ms));
+      window.setInterval = (fn, ms, ...args) => {
+        if (typeof fn !== 'function') return si(fn, ms);
+        let pending = false;
+        return si(() => { if (!paused) return fn(...args); if (!pending) { pending = true; held.push(() => { pending = false; fn(...args); }); } }, ms);
+      };
+      window.__FPX_PLAY_CLOCK__ = {
+        sleep: (ms) => new Promise((r) => st(r, ms)),
+        pause() {
+          if (paused) return;
+          paused = true; pausedAt = perfNow();
+          try { for (const x of document.getAnimations()) if (x.playState === 'running') { x.pause(); x.__fpxHeld = true; } } catch (e) { /* no Web Animations */ }
+        },
+        resume() {
+          if (!paused) return;
+          offset += perfNow() - pausedAt; paused = false;
+          try { for (const x of document.getAnimations()) if (x.__fpxHeld) { x.__fpxHeld = false; x.play(); } } catch (e) { /* no Web Animations */ }
+          for (const f of held.splice(0)) { try { f(); } catch (e) { st(() => { throw e; }); } }
+        },
+      };
+      window.addEventListener('error', (e) => { (window.__FPX_PLAY_ERRORS__ = window.__FPX_PLAY_ERRORS__ || []).push(String(e.message || e)); });
+    }
+  } else if (window.__FPX_PLAY_NONCE__ !== a.nonce) {
+    out.lost = true;
+    return JSON.stringify(out);
+  }
+  const clock = window.__FPX_PLAY_CLOCK__;
+  const sleep = clock.sleep;
+  const FRAME = 30, TAP = 60;
+  const at = (x, y) => document.elementFromPoint(x, y) || document.body;
+  const pointerType = a.touch ? 'touch' : 'mouse';
+  const fire = (target, type, x, y, down) => {
+    const common = { bubbles: true, cancelable: true, composed: true, clientX: x, clientY: y, screenX: x, screenY: y };
+    try {
+      target.dispatchEvent(new PointerEvent(type, { ...common, pointerId: a.touch ? 2 : 1, pointerType, isPrimary: true,
+        button: 0, buttons: down ? 1 : 0, pressure: down ? 0.5 : 0, width: a.touch ? 20 : 1, height: a.touch ? 20 : 1 }));
+    } catch (e) { /* no PointerEvent */ }
+    const phase = { pointerdown: 'start', pointermove: 'move', pointerup: 'end' }[type];
+    if (a.touch) {
+      try {
+        const t = new Touch({ identifier: 2, target, clientX: x, clientY: y, pageX: x, pageY: y, radiusX: 10, radiusY: 10, force: 0.5 });
+        target.dispatchEvent(new TouchEvent(`touch${phase}`, { bubbles: true, cancelable: true, composed: true,
+          touches: phase === 'end' ? [] : [t], targetTouches: phase === 'end' ? [] : [t], changedTouches: [t] }));
+      } catch (e) { /* no Touch constructor */ }
+    } else {
+      const mouse = { pointerdown: 'mousedown', pointermove: 'mousemove', pointerup: 'mouseup' }[type];
+      target.dispatchEvent(new MouseEvent(mouse, { ...common, button: 0, buttons: down ? 1 : 0 }));
+    }
+  };
+  const path = async (x1, y1, x2, y2, ms, click) => {
+    const target = at(x1, y1);
+    fire(target, 'pointerdown', x1, y1, true);
+    for (let t = FRAME; t < ms; t += FRAME) {
+      await sleep(FRAME);
+      const k = t / ms;
+      fire(target, 'pointermove', x1 + (x2 - x1) * k, y1 + (y2 - y1) * k, true);
+    }
+    await sleep(Math.max(0, ms % FRAME));
+    fire(target, 'pointerup', x2, y2, false);
+    if (click) target.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, composed: true, clientX: x2, clientY: y2 }));
+  };
+  const KEYS = { Space: ' ', Enter: 'Enter', Escape: 'Escape', Tab: 'Tab', Backspace: 'Backspace', Shift: 'Shift', Control: 'Control', Alt: 'Alt' };
+  const keyOf = (name) => {
+    if (/^[A-Za-z]$/.test(name)) return { key: name.toLowerCase(), code: `Key${name.toUpperCase()}` };
+    if (/^[0-9]$/.test(name)) return { key: name, code: `Digit${name}` };
+    if (/^Key[A-Z]$/.test(name)) return { key: name.slice(3).toLowerCase(), code: name };
+    if (/^Digit[0-9]$/.test(name)) return { key: name.slice(5), code: name };
+    const mod = /^(Shift|Control|Alt|Meta)(Left|Right)?$/.exec(name);
+    if (mod) return { key: mod[1], code: mod[2] ? name : `${mod[1]}Left`, mod: mod[1] };
+    return { key: KEYS[name] ?? name, code: name };
+  };
+  // Modifiers held down now: every key event carries them (shiftKey…), as a real keyboard's do.
+  const mods = new Set();
+  const key = (name, type) => {
+    const k = keyOf(name);
+    if (k.mod) { if (type === 'keydown') mods.add(k.mod); else mods.delete(k.mod); }
+    const flags = { shiftKey: mods.has('Shift'), ctrlKey: mods.has('Control'), altKey: mods.has('Alt'), metaKey: mods.has('Meta') };
+    (document.activeElement || document.body).dispatchEvent(new KeyboardEvent(type, { key: k.key, code: k.code, ...flags, bubbles: true, cancelable: true, composed: true }));
+  };
+  const before = (window.__FPX_PLAY_ERRORS__ || []).length;
+  clock.resume();
+  try {
+    for (const s of a.steps || []) {
+      try {
+        if (s.kind === 'tap') await path(s.x, s.y, s.x, s.y, TAP, true);
+        else if (s.kind === 'drag') await path(s.x1, s.y1, s.x2, s.y2, s.ms, false);
+        else if (s.kind === 'hold_at') await path(s.x, s.y, s.x, s.y, s.ms, false);
+        else if (s.kind === 'hold_key') { key(s.key, 'keydown'); await sleep(s.ms); key(s.key, 'keyup'); }
+        else if (s.kind === 'press') { for (let i = 0; i < s.times; i++) { key(s.key, 'keydown'); await sleep(40); key(s.key, 'keyup'); await sleep(60); } }
+        else if (s.kind === 'wait') await sleep(s.ms);
+        else throw new Error(`unknown step ${s.kind}`);
+        out.results.push({ ok: true, error: '' });
+      } catch (e) {
+        out.results.push({ ok: false, error: String((e && e.message) || e) });
+      }
+      out.played++;
+    }
+    // One frame for the last input to draw before the picture.
+    await sleep(50);
+  } finally {
+    clock.pause();
+  }
+  out.errors = (window.__FPX_PLAY_ERRORS__ || []).slice(before, before + 5);
+  return JSON.stringify(out);
+}

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

@@ -0,0 +1,33 @@
+// The painted-preview wait, before anything is measured: the page answered,
+// finished loading, its canvas was claimed by a renderer (off the 300x150
+// HTML default) and two frames were drawn. Waits up to a.budget_ms for the
+// first two, then gives two frames at most 500 ms each (a page whose rAF
+// never fires cannot hold the probe).
+// a = { budget_ms, default_width, default_height }
+// Returns JSON { status, ready_state, canvas, frames, waited_ms }:
+// status -1 = the browser did not say (not observed); canvas is 'none',
+// 'default' or 'claimed'.
+//
+// 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 start = performance.now();
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+  const frame = () => Promise.race([new Promise(r => requestAnimationFrame(() => r(true))), sleep(500).then(() => false)]);
+  const canvas = () => {
+    let best = null;
+    for (const c of document.querySelectorAll('canvas')) if (!best || c.width * c.height > best.width * best.height) best = c;
+    if (!best) return 'none';
+    return best.width === a.default_width && best.height === a.default_height ? 'default' : 'claimed';
+  };
+  while ((document.readyState !== 'complete' || canvas() === 'default') && performance.now() - start < a.budget_ms) await sleep(50);
+  let frames = 0;
+  for (let i = 0; i < 2; i++) if (await frame()) frames++;
+  let status = -1;
+  try {
+    const nav = performance.getEntriesByType('navigation')[0];
+    if (nav && typeof nav.responseStatus === 'number' && nav.responseStatus > 0) status = nav.responseStatus;
+  } catch (e) {}
+  return JSON.stringify({ status, ready_state: document.readyState, canvas: canvas(), frames, waited_ms: Math.round(performance.now() - start) });
+}

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

@@ -0,0 +1,54 @@
+// A real-time film of the play camera: MediaRecorder on the game's canvas stream (one GDK
+// build had to hand-write one to show a walk; screenshots every few hundred ms are not a
+// film, and a frozen clock is not real time). Records what the canvas draws at the game's own pace;
+// DOM over the canvas (the HUD) is not in it. Read-only to the game.
+//
+// Part of @funpixel/verify: one function expression of one argument. See mechanic_check.js for the
+// calling convention.
+//
+// a = { op: 'start', fps (30), bps (4_000_000) }  → { ok, mime, width, height } | { ok: false, error }
+//   | { op: 'stop' }                               → { ok, bytes, ms, mime, frames_hint } (kept in the page)
+//   | { op: 'read', offset, length }               → { ok, data (base64 slice), total }
+//   | { op: 'drop' }                               → { ok } (frees the kept film)
+async (a) => {
+  const KEY = '__FPX_FILM__';
+  const w = window;
+  const op = (a && a.op) || 'start';
+  if (op === 'read') {
+    const f = w[KEY];
+    if (!f || typeof f.b64 !== 'string') return JSON.stringify({ ok: false, error: 'no film kept' });
+    const off = Math.max(0, a.offset || 0), len = Math.max(1, a.length || 1_000_000);
+    return JSON.stringify({ ok: true, data: f.b64.slice(off, off + len), total: f.b64.length });
+  }
+  if (op === 'drop') { delete w[KEY]; return JSON.stringify({ ok: true }); }
+  if (op === 'stop') {
+    const f = w[KEY];
+    if (!f || !f.rec) return JSON.stringify({ ok: false, error: 'not recording' });
+    if (f.rec.state !== 'inactive') {
+      await new Promise((res) => { f.rec.onstop = res; try { f.rec.requestData(); } catch (e) { /* stopping anyway */ } f.rec.stop(); setTimeout(res, 3000); });
+    }
+    try { for (const t of f.stream.getTracks()) t.stop(); } catch (e) { /* gone */ }
+    const blob = new Blob(f.chunks, { type: f.mime });
+    const buf = new Uint8Array(await blob.arrayBuffer());
+    let bin = '';
+    for (let i = 0; i < buf.length; i += 0x8000) bin += String.fromCharCode.apply(null, buf.subarray(i, i + 0x8000));
+    f.b64 = btoa(bin);
+    f.rec = null; f.chunks = [];
+    return JSON.stringify({ ok: true, bytes: buf.length, ms: Math.round(performance.now() - f.t0), mime: f.mime });
+  }
+  // start: the largest canvas on the page is the play camera.
+  const canvases = [...document.querySelectorAll('canvas')].filter((c) => c.width > 0 && c.height > 0);
+  if (!canvases.length) return JSON.stringify({ ok: false, error: 'no canvas to film' });
+  const canvas = canvases.reduce((b, c) => (c.width * c.height > b.width * b.height ? c : b));
+  if (typeof canvas.captureStream !== 'function' || typeof MediaRecorder === 'undefined') return JSON.stringify({ ok: false, error: 'this browser has no canvas stream or MediaRecorder' });
+  const mime = ['video/webm;codecs=vp9', 'video/webm;codecs=vp8', 'video/webm', 'video/mp4'].find((m) => MediaRecorder.isTypeSupported && MediaRecorder.isTypeSupported(m));
+  if (!mime) return JSON.stringify({ ok: false, error: 'no video format MediaRecorder can write' });
+  if (w[KEY] && w[KEY].rec && w[KEY].rec.state !== 'inactive') { try { w[KEY].rec.stop(); } catch (e) { /* replaced */ } }
+  const stream = canvas.captureStream(a.fps || 30);
+  const rec = new MediaRecorder(stream, { mimeType: mime, videoBitsPerSecond: a.bps || 4_000_000 });
+  const f = { rec, stream, chunks: [], mime: mime.split(';')[0], t0: performance.now(), b64: null };
+  rec.ondataavailable = (e) => { if (e.data && e.data.size) f.chunks.push(e.data); };
+  rec.start(1000);
+  w[KEY] = f;
+  return JSON.stringify({ ok: true, mime: f.mime, width: canvas.width, height: canvas.height });
+}

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

@@ -0,0 +1,83 @@
+// Render health, three-state: was the canvas claimed by a renderer (read
+// PASSIVELY from its size — asking for a rendering context would create one), did the
+// graphics context survive, does every declared key have a touch route.
+// a = { default_width, default_height }
+//
+// 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) => {
+  const out = {
+    canvas_observed: false, canvas_claimed: false,
+    canvas_width: -1, canvas_height: -1,
+    context_loss_observed: false, context_lost: false,
+    key_parity_observed: false, unreachable_keys: [], touch_controls_found: 0,
+  };
+  try {
+    // --- canvas, read passively ---------------------------------------
+    const canvases = Array.from(document.querySelectorAll('canvas'));
+    if (canvases.length) {
+      // The biggest canvas is the game's; a tiny one is usually a helper
+      // (a glyph atlas, a minimap) and would answer for the wrong thing.
+      let best = canvases[0];
+      for (const c of canvases) {
+        if (c.width * c.height > best.width * best.height) best = c;
+      }
+      out.canvas_observed = true;
+      out.canvas_width = best.width | 0;
+      out.canvas_height = best.height | 0;
+      out.canvas_claimed = !(best.width === a.default_width && best.height === a.default_height);
+    }
+  } catch (e) {}
+  try {
+    if (window.__FPX_CTXWATCH__) {
+      out.context_loss_observed = true;
+      out.context_lost = window.__FPX_CTXLOST__ === true;
+    }
+  } catch (e) {}
+  try {
+    // --- key parity ----------------------------------------------------
+    // Only a game that TELLS us what it listens for can be judged. We read
+    // the declared verb table, whose entries name their key, and the
+    // on-screen controls that could deliver one on a phone.
+    // ONLY `__FPX_KEYS__` is judged. The verb table was tempting as a
+    // fallback, but a verb is a NAME, not a key: a game declaring
+    // `moveLeft` has no KeyMoveLeft to be unreachable, so falling back
+    // reported every verb of every uninstrumented-for-keys game as a
+    // mobile defect. A game that declares no key table is NOT OBSERVED.
+    const declared = window.__FPX_KEYS__;
+    if (declared && typeof declared === 'object') {
+      const touch = Array.from(document.querySelectorAll(
+        '[data-fpx-touch],[data-funpixel-control],button,[role="button"]'
+      ));
+      out.touch_controls_found = touch.length;
+      // A control claims the key it names, in whichever attribute the
+      // game used. Everything is compared lowercased.
+      const claimed = new Set();
+      for (const el of touch) {
+        for (const a of ['data-fpx-touch', 'data-funpixel-control', 'data-key', 'aria-label']) {
+          const v = el.getAttribute && el.getAttribute(a);
+          if (v) claimed.add(String(v).trim().toLowerCase());
+        }
+      }
+      // A swipe on the play claims the keys it stands for (data-fpx-gesture="ArrowLeft ArrowRight …"):
+      // a board puzzle moved by a swipe needs no pad to be reachable on a phone.
+      for (const el of document.querySelectorAll('[data-fpx-gesture]')) {
+        for (const k of String(el.getAttribute('data-fpx-gesture') || '').split(/[\s,]+/)) if (k) claimed.add(k.toLowerCase());
+      }
+      const owners = window.__FPX_KEY_OWNERS__ || {};
+      const missing = [];
+      for (const name of Object.keys(declared)) {
+        const k = String(name).trim().toLowerCase();
+        if (!k) continue;
+        if (claimed.has(k)) continue;
+        const owner = owners[name] || owners[k];
+        missing.push(owner ? (name + '(' + owner + ')') : name);
+      }
+      out.key_parity_observed = true;
+      out.unreachable_keys = missing.slice(0, 24);
+    }
+  } catch (e) {}
+  return JSON.stringify(out);
+}
+

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

@@ -0,0 +1,75 @@
+// Renderer counters (plan f17): draw calls and triangles per frame, summed over
+// every render pass, for any WebGL engine. Three resets renderer.info on each
+// render(), so a scene with a post-processing pass reads "1 draw call"; counting
+// the draw calls themselves has no such blind spot and needs no engine hook.
+// a = { op: 'install' } wraps the draw methods on the WebGL prototypes (a
+// context made before the install counts too: engines look the method up on
+// each call); a = { op: 'read', frames } then samples that many animation
+// frames, the calls between two of our frame callbacks being one frame's.
+// Returns JSON { observed, frames, draw_calls_max, draw_calls_p50,
+// triangles_max, triangles_p50 }. Nothing drawn through WebGL while we watched
+// (a 2D canvas, a DOM game, a game that draws only on input) = not observed.
+// Evidence, never a verdict: the same budgets as measure_performance (100 draw
+// calls, 150K triangles) are the caller's note.
+//
+// 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 w = window;
+  if (a.op === 'install') {
+    if (w.__FPX_DRAWS__) return 'already';
+    const c = { calls: 0, tris: 0 };
+    w.__FPX_DRAWS__ = c;
+    // TRIANGLES, TRIANGLE_STRIP, TRIANGLE_FAN; points and lines draw no triangles.
+    const tris = (mode, count) => (mode === 4 ? Math.floor(count / 3) : mode === 5 || mode === 6 ? Math.max(0, count - 2) : 0);
+    const wrap = (proto, name, countAt, instAt) => {
+      // Own methods only: wrapping one a prototype inherits would count it twice.
+      if (!proto || !Object.prototype.hasOwnProperty.call(proto, name)) return;
+      const orig = proto[name];
+      if (typeof orig !== 'function') return;
+      proto[name] = function (...args) {
+        const inst = instAt < 0 ? 1 : Math.max(0, args[instAt] | 0);
+        c.calls++;
+        c.tris += tris(args[0], args[countAt] | 0) * inst;
+        return orig.apply(this, args);
+      };
+    };
+    for (const P of [w.WebGLRenderingContext, w.WebGL2RenderingContext]) {
+      if (!P) continue;
+      wrap(P.prototype, 'drawArrays', 2, -1);
+      wrap(P.prototype, 'drawElements', 1, -1);
+    }
+    if (w.WebGL2RenderingContext) {
+      const p = w.WebGL2RenderingContext.prototype;
+      wrap(p, 'drawArraysInstanced', 2, 3);
+      wrap(p, 'drawElementsInstanced', 1, 4);
+      wrap(p, 'drawRangeElements', 3, -1);
+    }
+    if (w.ANGLEInstancedArrays) {
+      wrap(w.ANGLEInstancedArrays.prototype, 'drawArraysInstancedANGLE', 2, 3);
+      wrap(w.ANGLEInstancedArrays.prototype, 'drawElementsInstancedANGLE', 1, 4);
+    }
+    return 'installed';
+  }
+  const out = { observed: false, frames: 0, draw_calls_max: 0, draw_calls_p50: 0, triangles_max: 0, triangles_p50: 0 };
+  const c = w.__FPX_DRAWS__;
+  if (!c) return JSON.stringify(out);
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const raf = () => Promise.race([new Promise((r) => requestAnimationFrame(r)), sleep(200)]);
+  await raf();
+  const calls = [], triangles = [];
+  let lc = c.calls, lt = c.tris;
+  for (let i = 0; i < a.frames; i++) {
+    await raf();
+    calls.push(c.calls - lc); triangles.push(c.tris - lt);
+    lc = c.calls; lt = c.tris;
+  }
+  if (!calls.some((n) => n > 0)) return JSON.stringify(out);
+  const p50 = (xs) => xs.slice().sort((x, y) => x - y)[Math.floor(xs.length / 2)];
+  out.observed = true;
+  out.frames = calls.length;
+  out.draw_calls_max = Math.max(...calls); out.draw_calls_p50 = p50(calls);
+  out.triangles_max = Math.max(...triangles); out.triangles_p50 = p50(triangles);
+  return JSON.stringify(out);
+}

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

@@ -0,0 +1,222 @@
+// Walk the engine's scene graph and say what is in it (plan m10
+// `inspect_scene`): Three's Scene, Pixi's stage, or Phaser's display lists,
+// found through the handles the probe already reads (__THREEJS_SCENE__ +
+// camera, __PIXI_APP__) or the ones each engine's devtools use. Read-only: it
+// changes nothing that is drawn (Three may cache a geometry's bounding box).
+//
+// Part of @funpixel/verify: one function expression of one argument. See
+// mechanic_check.js for the calling convention.
+//
+// a = { max_nodes, max_listed, phone_max_side }
+//
+// Answers JSON:
+//   engine     — three | pixi | phaser | none; handle — the global it came from
+//   nodes, max_depth, kinds { kind: count }, truncated (max_nodes reached)
+//   visible    — drawable nodes that draw; hidden — drawable nodes switched off
+//                (visible false, alpha 0, scale 0, an ancestor off) with names
+//   offscreen  — drawable, switched on, and wholly outside the view: names
+//   textures   — { count, bytes (RGBA estimate, mips included), npot,
+//                  oversized (a side over phone_max_side), list: [{ name, w, h }] }
+//   draw_calls — { estimate, basis }: a hint from the tree, not a measurement
+//                (the probe's renderer counters measure it)
+//   renderer   — what the engine itself reports, when it does
+//   hint       — how to expose the scene when engine is none
+async (a) => {
+  const MAX = a.max_nodes || 20000, LIST = a.max_listed || 20, PHONE = a.phone_max_side || 2048;
+  const out = {
+    engine: 'none', handle: '', nodes: 0, max_depth: 0, kinds: {}, truncated: false,
+    visible: 0, hidden: { total: 0, names: [] }, offscreen: { total: 0, names: [] },
+    textures: { count: 0, bytes: 0, npot: 0, oversized: 0, list: [] },
+    draw_calls: { estimate: 0, basis: '' }, renderer: null, hint: '',
+  };
+  const note = (bucket, name) => { bucket.total++; if (bucket.names.length < LIST) bucket.names.push(name || '(unnamed)'); };
+  const kind = (k) => { out.kinds[k] = (out.kinds[k] || 0) + 1; };
+  const pot = (n) => n > 0 && (n & (n - 1)) === 0;
+  const textures = new Map();
+  const texture = (key, name, w, h, compressed) => {
+    if (!key || textures.has(key) || !(w > 0 && h > 0)) return;
+    textures.set(key, true);
+    const t = out.textures;
+    t.count++;
+    t.bytes += Math.round(w * h * (compressed ? 1 : 4) * 4 / 3);
+    if (!pot(w) || !pot(h)) t.npot++;
+    if (Math.max(w, h) > PHONE) t.oversized++;
+    t.list.push({ name: String(name || '').slice(0, 80), w, h });
+  };
+  const finish = () => {
+    out.textures.list.sort((x, y) => y.w * y.h - x.w * x.h);
+    out.textures.list = out.textures.list.slice(0, LIST);
+    return JSON.stringify(out);
+  };
+
+  // --- Three ---------------------------------------------------------------
+  const scene = window.__THREEJS_SCENE__ || (window.scene && window.scene.isScene ? window.scene : null);
+  if (scene && scene.isObject3D) {
+    out.engine = 'three';
+    out.handle = window.__THREEJS_SCENE__ ? '__THREEJS_SCENE__' : 'scene';
+    const cam = window.camera || window.__THREEJS_CAMERA__ || null;
+    const T = window.THREE;
+    let frustum = null;
+    if (cam && cam.isCamera && T && T.Frustum && T.Matrix4 && T.Box3) {
+      cam.updateMatrixWorld?.();
+      frustum = new T.Frustum().setFromProjectionMatrix(new T.Matrix4().multiplyMatrices(cam.projectionMatrix, cam.matrixWorldInverse));
+    }
+    const SLOTS = ['map', 'normalMap', 'roughnessMap', 'metalnessMap', 'emissiveMap', 'aoMap', 'alphaMap', 'bumpMap', 'displacementMap', 'lightMap', 'envMap', 'specularMap'];
+    const materials = new Set();
+    let calls = 0;
+    const walk = (o, depth, on) => {
+      if (out.nodes >= MAX) { out.truncated = true; return; }
+      out.nodes++;
+      out.max_depth = Math.max(out.max_depth, depth);
+      const shown = on && o.visible !== false;
+      const drawable = o.isMesh || o.isPoints || o.isLine || o.isSprite;
+      kind(o.isInstancedMesh ? 'InstancedMesh' : o.isSkinnedMesh ? 'SkinnedMesh' : o.isMesh ? 'Mesh' : o.isPoints ? 'Points'
+        : o.isLine ? 'Line' : o.isSprite ? 'Sprite' : o.isLight ? 'Light' : o.isBone ? 'Bone' : o.isCamera ? 'Camera' : 'Group');
+      if (drawable) {
+        const mats = Array.isArray(o.material) ? o.material : o.material ? [o.material] : [];
+        const faded = mats.length > 0 && mats.every((m) => m.visible === false || (m.transparent && m.opacity === 0));
+        const flat = o.scale && (o.scale.x === 0 || o.scale.y === 0 || o.scale.z === 0);
+        if (!shown || faded || flat) note(out.hidden, o.name);
+        else {
+          let inView = true;
+          if (frustum && !o.isSprite) {
+            try { inView = frustum.intersectsBox(new T.Box3().setFromObject(o)); } catch (e) { inView = true; }
+          }
+          if (!inView) note(out.offscreen, o.name);
+          else {
+            out.visible++;
+            calls += Array.isArray(o.material) && o.geometry && o.geometry.groups ? Math.max(1, o.geometry.groups.length) : 1;
+          }
+        }
+        for (const m of mats) {
+          materials.add(m);
+          for (const s of SLOTS) {
+            const t = m[s];
+            if (!t || !t.isTexture) continue;
+            const img = t.image || (t.mipmaps && t.mipmaps[0]) || {};
+            const w = img.width || img.videoWidth || (img.data && t.image && t.image.width) || 0;
+            const h = img.height || img.videoHeight || 0;
+            texture(t.uuid || t, t.name || (img.currentSrc || img.src || '').split('/').pop() || s, w, h, !!t.isCompressedTexture);
+          }
+        }
+      }
+      for (const c of o.children || []) walk(c, depth + 1, shown);
+    };
+    walk(scene, 0, true);
+    out.kinds.materials = materials.size;
+    out.draw_calls = { estimate: calls, basis: 'one per visible mesh in view, one per material group; instanced meshes count once; shadow and post passes add more' };
+    const r = window.__THREEJS_RENDERER__ || window.renderer;
+    if (r && r.info && r.info.render) {
+      out.renderer = { calls: r.info.render.calls, triangles: r.info.render.triangles, textures: r.info.memory?.textures, geometries: r.info.memory?.geometries, programs: Array.isArray(r.info.programs) ? r.info.programs.length : undefined };
+    }
+    return finish();
+  }
+
+  // --- Pixi (v7 and v8) ----------------------------------------------------
+  const app = window.__PIXI_APP__ || (window.__PIXI_DEVTOOLS__ && window.__PIXI_DEVTOOLS__.app) || null;
+  const stage = (app && app.stage) || window.__PIXI_STAGE__ || (window.__PIXI_DEVTOOLS__ && window.__PIXI_DEVTOOLS__.stage) || null;
+  if (stage && Array.isArray(stage.children)) {
+    out.engine = 'pixi';
+    out.handle = window.__PIXI_APP__ ? '__PIXI_APP__' : window.__PIXI_STAGE__ ? '__PIXI_STAGE__' : '__PIXI_DEVTOOLS__';
+    const screen = (app && (app.screen || (app.renderer && app.renderer.screen))) || { x: 0, y: 0, width: innerWidth, height: innerHeight };
+    const pipeOf = (o) => o.renderPipeId || o.pluginName
+      || (typeof o.text === 'string' ? 'text' : o.texture ? 'sprite' : o.geometry ? 'graphics' : '');
+    let calls = 0, lastPipe = '', runTextures = new Set();
+    const walk = (o, depth, on, alpha) => {
+      if (out.nodes >= MAX) { out.truncated = true; return; }
+      out.nodes++;
+      out.max_depth = Math.max(out.max_depth, depth);
+      const a2 = alpha * (o.alpha ?? 1);
+      const shown = on && o.visible !== false && o.renderable !== false;
+      const pipe = pipeOf(o);
+      kind(pipe || (o.children && o.children.length ? 'container' : 'empty'));
+      if (pipe) {
+        const sc = o.scale || { x: 1, y: 1 };
+        const name = o.label || o.name || '';
+        if (!shown || a2 <= 0.01 || sc.x === 0 || sc.y === 0) note(out.hidden, name);
+        else {
+          let inView = true;
+          try {
+            const b = o.getBounds();
+            const bx = b.x ?? b.minX, by = b.y ?? b.minY, bw = b.width ?? (b.maxX - b.minX), bh = b.height ?? (b.maxY - b.minY);
+            inView = bx < screen.x + screen.width && by < screen.y + screen.height && bx + bw > screen.x && by + bh > screen.y;
+          } catch (e) { inView = true; }
+          if (!inView) note(out.offscreen, name);
+          else {
+            out.visible++;
+            const src = o.texture && (o.texture.source || o.texture.baseTexture);
+            // A batch breaks on a new pipe, or past 16 textures in one run.
+            if (pipe !== lastPipe || pipe !== 'sprite' || (src && !runTextures.has(src) && runTextures.size >= 16)) {
+              calls++;
+              runTextures = new Set();
+            }
+            if (src) runTextures.add(src);
+            lastPipe = pipe;
+          }
+        }
+        const src = o.texture && (o.texture.source || o.texture.baseTexture);
+        if (src) {
+          const w = src.pixelWidth || src.realWidth || src.width || 0, h = src.pixelHeight || src.realHeight || src.height || 0;
+          const res = src.resource || {};
+          texture(src, src.label || src.cacheId || (res.src || res.url || '').split('/').pop() || name, w, h, !!(src.format && /bc|etc|astc|pvrtc/i.test(String(src.format))));
+        }
+      }
+      for (const c of o.children || []) walk(c, depth + 1, shown, a2);
+    };
+    walk(stage, 0, true, 1);
+    out.draw_calls = { estimate: calls, basis: 'batches in render order: a new one at every change of kind (sprite, graphics, text, mesh) and every 16 textures; filters and masks add more' };
+    return finish();
+  }
+
+  // --- Phaser 3 ------------------------------------------------------------
+  const game = window.__PHASER_GAME__ || window.game || window.phaserGame || null;
+  if (game && game.scene && Array.isArray(game.scene.scenes)) {
+    out.engine = 'phaser';
+    out.handle = window.__PHASER_GAME__ ? '__PHASER_GAME__' : window.game ? 'game' : 'phaserGame';
+    let calls = 0, lastKey = null;
+    const walk = (o, depth, on, view) => {
+      if (out.nodes >= MAX) { out.truncated = true; return; }
+      out.nodes++;
+      out.max_depth = Math.max(out.max_depth, depth);
+      kind(o.type || 'GameObject');
+      const shown = on && o.visible !== false && (o.alpha ?? 1) > 0.01 && o.scaleX !== 0 && o.scaleY !== 0;
+      if (o.type === 'Container' || Array.isArray(o.list)) {
+        for (const c of o.list || []) walk(c, depth + 1, shown, view);
+        return;
+      }
+      if (!shown) { note(out.hidden, o.name); return; }
+      let inView = true;
+      try {
+        if (view && o.getBounds && o.scrollFactorX !== 0) {
+          const b = o.getBounds();
+          inView = b.x < view.x + view.width && b.y < view.y + view.height && b.right > view.x && b.bottom > view.y;
+        }
+      } catch (e) { inView = true; }
+      if (!inView) { note(out.offscreen, o.name); return; }
+      out.visible++;
+      const key = o.texture && o.texture.key;
+      if (key !== lastKey || !key) calls++;
+      lastKey = key;
+    };
+    for (const s of game.scene.scenes) {
+      const sys = s.sys;
+      if (!sys || !(sys.isActive ? sys.isActive() : sys.settings && sys.settings.active)) continue;
+      const cam = s.cameras && s.cameras.main;
+      for (const o of (s.children && s.children.list) || []) walk(o, 1, sys.isVisible ? sys.isVisible() : true, cam && cam.worldView);
+    }
+    const list = (game.textures && game.textures.list) || {};
+    for (const key of Object.keys(list)) {
+      if (key.startsWith('__')) continue;
+      const src = list[key].source && list[key].source[0];
+      if (src) texture(key, key, src.width, src.height, !!src.compressionAlgorithm);
+    }
+    out.draw_calls = { estimate: calls, basis: 'one per run of objects on the same texture in display order; graphics, masks and pipelines add more' };
+    const r = game.renderer;
+    if (r && r.type !== undefined) out.renderer = { type: r.type === 2 ? 'webgl' : r.type === 1 ? 'canvas' : String(r.type) };
+    return finish();
+  }
+
+  out.hint = 'No scene graph found. Expose it the way the probe reads it: Three — window.__THREEJS_SCENE__ = scene, '
+    + 'window.camera = camera, window.THREE = THREE; Pixi — window.__PIXI_APP__ = app; Phaser — window.__PHASER_GAME__ = game.';
+  return finish();
+}