@funpixel/tools 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,258 @@
+// Where the player and the threats are on screen, from the engine's own scene
+// graph (research 15 M6, `funtools look --read`): each node that plays the
+// player or a threat, drawn and switched on, as a box in CSS pixels of the
+// page. Pixi through getBounds(). Three by projecting the POSED mesh (its
+// vertices as skinned and morphed now, sampled; a bounding box is the bind
+// pose) and each instance of an InstancedMesh through the camera. A matched
+// node's children are part of it, never matched again. Read-only.
+//
+// Three only: an actor must be SEEN to be measured. Rays go from the camera to
+// its centre and to 0.6 m either side of it (camera right and up) against every
+// other drawn, opaque mesh; when all five are blocked (behind a wall, a shut
+// door) or off screen, it goes in `hidden`, not in `actors` — one game: all 8
+// threats measured were behind walls, so their ΔE measured the walls.
+//
+// Who plays a role, most specific first, decided per role:
+//   tag      — the node says so: userData.role "player" | "threat", or a name
+//              that starts with the role (player-ines, threat-walker-3). Once
+//              any node in the scene, shown or not, carries a role's tag, only
+//              tagged nodes play that role, so a prop named hazard_barrier is
+//              scenery (one game: the usual words measured it as the threat)
+//   declared — the caller's pattern (funpixel.json "actors", --player/--threats)
+//   words    — the usual words (player|hero|avatar; enemy|threat|hazard|…)
+// `matched` says per role which of the three picked, and the node names it
+// picked, so a wrong match is seen instead of silently measured.
+//
+// Part of @funpixel/verify: one function expression of one argument. See
+// mechanic_check.js for the calling convention.
+//
+// a = { player: regex source, threats: regex source, max: boxes per role }
+//
+// Answers JSON:
+//   engine  — three | pixi | none
+//   actors  — [{ role: player | threat, name, x, y, w, h }] (CSS px, clipped to nothing)
+//   matched — { player, threat }: { by: tag | declared | words, names (distinct, up to 12), count }
+//             (count: nodes matched while shown, boxed or not)
+//   names   — up to 40 distinct node names seen, so a caller can say what to match
+//   hidden  — [{ role, name }]: matched, drawn, but not visible from the camera (Three)
+//   occlusion — tested | not_observed (the scene was too big to ray in the time; every
+//             actor is boxed as before) | none (Pixi: a 2D stage has no walls in depth)
+//   error   — why no box could be made (no camera, no canvas)
+async (a) => {
+  const MAX = a.max || 40;
+  const ROLES = ['player', 'threat'];
+  const pattern = {
+    player: new RegExp(a.player || 'player|hero|avatar', 'i'),
+    threat: new RegExp(a.threats || 'enemy|enemies|foe|threat|monster|mob|zombie|hazard|bullet|projectile|boss|creep', 'i'),
+  };
+  const fallback = { player: a.player ? 'declared' : 'words', threat: a.threats ? 'declared' : 'words' };
+  const PREFIX = /^(player|threat)(?:$|[-_:.#\s])/i;
+  const out = { engine: 'none', actors: [], matched: {}, names: [], hidden: [], occlusion: 'none', error: '' };
+  const seen = new Set();
+  const counts = { player: 0, threat: 0 };
+  const noteName = (n) => { if (n && !seen.has(n) && seen.size < 40) { seen.add(n); out.names.push(n); } };
+  const tagOf = (o, name) => {
+    const r = o && o.userData && typeof o.userData.role === 'string' ? o.userData.role.toLowerCase() : '';
+    if (r === 'player' || r === 'threat') return r;
+    const m = PREFIX.exec(name || '');
+    return m ? m[1].toLowerCase() : null;
+  };
+  // How each role is found: by tag when any node, shown or not, carries that role's tag.
+  const plan = (root, nameOf) => {
+    const tagged = { player: false, threat: false };
+    const stack = [root];
+    for (let n = 0; stack.length && n < 50000; n++) {
+      const o = stack.pop();
+      const t = tagOf(o, nameOf(o));
+      if (t) { tagged[t] = true; continue; }
+      for (const c of o.children || []) stack.push(c);
+    }
+    for (const r of ROLES) out.matched[r] = { by: tagged[r] ? 'tag' : fallback[r], names: [], count: 0 };
+  };
+  const roleOf = (o, name) => {
+    const t = tagOf(o, name);
+    if (t) return t;
+    if (!name) return null;
+    return ROLES.find((r) => out.matched[r].by !== 'tag' && pattern[r].test(name)) || null;
+  };
+  const note = (role, name) => {
+    const m = out.matched[role];
+    m.count++;
+    if (name && m.names.length < 12 && !m.names.includes(name)) m.names.push(name);
+  };
+  const push = (role, name, b) => {
+    if (!(b.w > 1 && b.h > 1) || counts[role] >= MAX) return;
+    counts[role]++;
+    out.actors.push({ role, name, x: Math.round(b.x), y: Math.round(b.y), w: Math.round(b.w), h: Math.round(b.h) });
+  };
+
+  // --- 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__ || null;
+  if (stage && Array.isArray(stage.children)) {
+    out.engine = 'pixi';
+    plan(stage, (o) => o.label || o.name || '');
+    const r = app && app.renderer;
+    const canvas = (app && (app.canvas || app.view)) || (r && (r.canvas || r.view)) || document.querySelector('canvas');
+    const screen = (app && (app.screen || (r && r.screen))) || { x: 0, y: 0, width: innerWidth, height: innerHeight };
+    const rect = canvas && canvas.getBoundingClientRect ? canvas.getBoundingClientRect() : { left: 0, top: 0, width: screen.width, height: screen.height };
+    const sx = rect.width / (screen.width || rect.width || 1), sy = rect.height / (screen.height || rect.height || 1);
+    const walk = (o, on, alpha) => {
+      const a2 = alpha * (o.alpha ?? 1);
+      const shown = on && o.visible !== false && o.renderable !== false && a2 > 0.01;
+      if (!shown) return;
+      const name = o.label || o.name || '';
+      noteName(name);
+      const role = roleOf(o, name);
+      if (role) {
+        note(role, name);
+        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);
+          push(role, name, { x: rect.left + (bx - screen.x) * sx, y: rect.top + (by - screen.y) * sy, w: bw * sx, h: bh * sy });
+        } catch (e) { /* a node that cannot measure itself */ }
+        return;
+      }
+      for (const c of o.children || []) walk(c, shown, a2);
+    };
+    walk(stage, true, 1);
+    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';
+    plan(scene, (o) => o.name || '');
+    const cam = window.camera || window.__THREEJS_CAMERA__ || null;
+    const r = window.__THREEJS_RENDERER__ || window.renderer;
+    const canvas = (r && r.domElement) || document.querySelector('canvas');
+    if (!cam || !cam.isCamera) { out.error = 'no camera: expose it as window.camera'; return JSON.stringify(out); }
+    if (!canvas) { out.error = 'no canvas'; return JSON.stringify(out); }
+    const rect = canvas.getBoundingClientRect();
+    cam.updateMatrixWorld && cam.updateMatrixWorld();
+    const V = scene.position.constructor, M = scene.matrixWorld.constructor;
+    scene.updateMatrixWorld && scene.updateMatrixWorld();
+    const toPage = (p) => ({ x: rect.left + ((p.x + 1) / 2) * rect.width, y: rect.top + ((1 - p.y) / 2) * rect.height });
+    // One world point into the page box and the world box (both grown in place).
+    const add = (w, box, wb) => {
+      wb.min.x = Math.min(wb.min.x, w.x); wb.min.y = Math.min(wb.min.y, w.y); wb.min.z = Math.min(wb.min.z, w.z);
+      wb.max.x = Math.max(wb.max.x, w.x); wb.max.y = Math.max(wb.max.y, w.y); wb.max.z = Math.max(wb.max.z, w.z);
+      const p = w.clone().project(cam);
+      if (p.z > 1 || p.z < -1) return;
+      const q = toPage(p);
+      box.x0 = Math.min(box.x0, q.x); box.y0 = Math.min(box.y0, q.y); box.x1 = Math.max(box.x1, q.x); box.y1 = Math.max(box.y1, q.y);
+    };
+    // A mesh as posed now: its vertices (skinned, morphed; at most ~1500 sampled), else its bounding box's corners.
+    const project = (mesh, world, box, wb, posed) => {
+      const g = mesh.geometry;
+      if (!g) return;
+      const pos = g.attributes && g.attributes.position;
+      if (posed && pos && typeof mesh.getVertexPosition === 'function') {
+        const step = Math.max(1, Math.ceil(pos.count / 1500)), v = new V();
+        for (let i = 0; i < pos.count; i += step) { mesh.getVertexPosition(i, v); add(v.applyMatrix4(world), box, wb); }
+        return;
+      }
+      if (!g.boundingBox && g.computeBoundingBox) g.computeBoundingBox();
+      const bb = g.boundingBox;
+      if (!bb) return;
+      for (const x of [bb.min.x, bb.max.x]) for (const y of [bb.min.y, bb.max.y]) for (const z of [bb.min.z, bb.max.z]) add(new V(x, y, z).applyMatrix4(world), box, wb);
+    };
+    const clip = (b) => {
+      const x0 = Math.max(b.x0, rect.left), y0 = Math.max(b.y0, rect.top), x1 = Math.min(b.x1, rect.left + rect.width), y1 = Math.min(b.y1, rect.top + rect.height);
+      return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+    };
+    const empty = () => ({ x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity });
+    const emptyW = () => ({ min: new V(Infinity, Infinity, Infinity), max: new V(-Infinity, -Infinity, -Infinity) });
+
+    // --- occlusion: what the camera can see ---------------------------------
+    // Occluders: every drawn mesh a player could not see through. Rays use the
+    // meshes' own raycast() with a stand-in raycaster (the page's THREE is not
+    // ours to import): origin, direction and the two tests three asks of it.
+    const occluders = [];
+    const opaque = (m) => [].concat(m || []).some((x) => x && x.visible !== false && !(x.transparent && (x.opacity ?? 1) < 0.5) && x.colorWrite !== false);
+    const gather = (o, on) => {
+      const shown = on && o.visible !== false;
+      if (!shown) return;
+      if (o.isMesh && opaque(o.material) && occluders.length < 6000) occluders.push(o);
+      for (const c of o.children || []) gather(c, shown);
+    };
+    gather(scene, true);
+    const BUDGET_MS = 2500, t0 = performance.now();
+    let timedOut = false;
+    const ray = {
+      origin: new V(), direction: new V(),
+      distanceSqToPoint(p) { const d = p.clone().sub(this.origin).dot(this.direction); return d < 0 ? this.origin.distanceToSquared(p) : this.direction.clone().multiplyScalar(d).add(this.origin).distanceToSquared(p); },
+      intersectsSphere(s) { return this.distanceSqToPoint(s.center) <= s.radius * s.radius; },
+    };
+    const caster = { ray, near: 0, far: Infinity, camera: cam, layers: cam.layers, params: { Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }, firstHitOnly: true };
+    // Is this world point visible: on screen, and no other mesh between it and the camera?
+    const seen = (w, own) => {
+      const p = w.clone().project(cam);
+      if (Math.abs(p.x) > 1 || Math.abs(p.y) > 1 || p.z > 1 || p.z < -1) return false;
+      ray.origin.set(p.x, p.y, -1).unproject(cam);
+      ray.direction.copy(w).sub(ray.origin);
+      const dist = ray.direction.length();
+      if (!(dist > 0)) return true;
+      ray.direction.multiplyScalar(1 / dist);
+      caster.far = dist;
+      const tol = Math.max(0.05, dist * 0.02);
+      for (const o of occluders) {
+        if (own.has(o)) continue;
+        if (performance.now() - t0 > BUDGET_MS) { timedOut = true; return true; }
+        const hits = [];
+        try { o.raycast(caster, hits); } catch (e) { continue; }
+        if (hits.some((h) => h.distance < dist - tol)) return false;
+      }
+      return true;
+    };
+    // A page whose Vector3 can't do this (an old or stand-in THREE) gets no visibility test: not observed, never a crash.
+    let right = null, up = null;
+    try {
+      right = new V().setFromMatrixColumn(cam.matrixWorld, 0).normalize().multiplyScalar(0.6);
+      up = new V().setFromMatrixColumn(cam.matrixWorld, 1).normalize().multiplyScalar(0.6);
+    } catch (e) { timedOut = true; }
+    // Seen = the centre or any of the four points 0.6 m around it (the ±0.6 m a player glimpses an edge by).
+    const visible = (wb, own) => {
+      if (!(wb.max.x >= wb.min.x)) return false;
+      const c = wb.min.clone().add(wb.max).multiplyScalar(0.5);
+      return [c, c.clone().add(right), c.clone().sub(right), c.clone().add(up), c.clone().sub(up)].some((w) => seen(w, own));
+    };
+    const meshesOf = (o) => { const s = new Set(); const each = (m) => { if (m.isMesh) s.add(m); for (const c of m.children || []) each(c); }; each(o); return s; };
+    const place = (role, name, box, wb, own) => {
+      let hidden = false;
+      if (!timedOut) { try { hidden = !visible(wb, own); } catch (e) { timedOut = true; } }
+      if (hidden) { out.hidden.push({ role, name }); return; }
+      push(role, name, clip(box));
+    };
+
+    const walk = (o, on) => {
+      const shown = on && o.visible !== false;
+      if (!shown) return;
+      noteName(o.name);
+      const role = roleOf(o, o.name);
+      if (!role) { for (const c of o.children || []) walk(c, shown); return; }
+      note(role, o.name);
+      const own = meshesOf(o);
+      if (o.isInstancedMesh && o.getMatrixAt) {
+        const inst = new M(), world = new M();
+        for (let i = 0; i < Math.min(o.count, MAX); i++) {
+          o.getMatrixAt(i, inst);
+          const box = empty(), wb = emptyW();
+          project(o, world.multiplyMatrices(o.matrixWorld, inst), box, wb, false);
+          place(role, `${o.name}#${i}`, box, wb, own);
+        }
+        return;
+      }
+      const box = empty(), wb = emptyW();
+      const each = (m) => { if (m.visible === false) return; if (m.isMesh || m.isSprite || m.isPoints) project(m, m.matrixWorld, box, wb, m.isMesh); for (const c of m.children || []) each(c); };
+      each(o);
+      place(role, o.name, box, wb, own);
+    };
+    walk(scene, true);
+    out.occlusion = timedOut ? 'not_observed' : 'tested';
+    return JSON.stringify(out);
+  }
+  out.error = 'no Pixi stage or Three scene found (window.__PIXI_APP__, or window.__THREEJS_SCENE__ with window.camera)';
+  return JSON.stringify(out);
+}

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

@@ -0,0 +1,106 @@
+// Does the game make sound? a = { op: 'install' | 'read' }.
+//
+// 'install' (before any check runs) wraps the page's audio entry points on
+// their prototypes, so instances made before the install count too: every
+// Web Audio source start(), every HTMLMediaElement play(), every connect() to
+// a destination and every resume(). Counts are keyed per cue (a media file's
+// name, an AudioBuffer's identity, an oscillator) so one hit playing four
+// times is visible. A source or element started with `loop` set counts in
+// `loop_starts` too (an ambient bed; funtools life reads it).
+// mechanic_check.js reads the same log around each check.
+// 'read' reports it, three-state: `observed` false = no listener on this page.
+// 'read' with `since` (and `until`), in the page's performance.now() ms, adds
+// `between`: { starts, cues } for the sounds started in that span (every start
+// is stamped, the last 2048 kept), so a judge counts exactly the window it
+// watched (funtools life: play before a big moment, and after its mark).
+//
+// A silent game passes every screenshot and every bot; four native games of
+// ours shipped that way. The game says it has sound with window.__FPX_AUDIO__.
+//
+// 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 w = window;
+  if (a && a.op === 'read') {
+    const log = w.__FPX_AUDIO_LOG__;
+    const out = {
+      observed: !!log, declared: !!w.__FPX_AUDIO__,
+      contexts: 0, context_state: '', resumes: 0,
+      sources_started: 0, media_plays: 0, destination_connections: 0, loop_starts: 0, cues: '',
+    };
+    if (log) {
+      out.contexts = log.contexts; out.context_state = log.ctx ? String(log.ctx.state || '') : ''; out.resumes = log.resumes;
+      out.sources_started = log.starts; out.media_plays = log.plays; out.destination_connections = log.dest;
+      out.loop_starts = log.loops || 0;
+      out.cues = Object.entries(log.cues).sort((x, y) => y[1] - x[1] || (x[0] < y[0] ? -1 : 1))
+        .slice(0, 4).map(([k, n]) => k + ' x' + n).join(', ');
+      if (typeof a.since === 'number') {
+        const until = typeof a.until === 'number' ? a.until : Infinity;
+        const between = { starts: 0, cues: {} };
+        for (const [t, name] of log.times || []) {
+          if (t < a.since || t > until) continue;
+          between.starts++;
+          between.cues[name] = (between.cues[name] || 0) + 1;
+        }
+        out.between = between;
+      }
+    }
+    return JSON.stringify(out);
+  }
+  try {
+    if (w.__FPX_AUDIO_LOG__) return 'already';
+    const log = { contexts: 0, ctx: null, resumes: 0, starts: 0, plays: 0, dest: 0, loops: 0, cues: {}, times: [] };
+    const seen = new WeakSet(), ids = new WeakMap();
+    let next = 1;
+    const note = (ctx) => {
+      if (!ctx) return;
+      if (!seen.has(ctx)) { seen.add(ctx); log.contexts++; }
+      log.ctx = ctx;
+    };
+    const cue = (name) => {
+      log.cues[name] = (log.cues[name] || 0) + 1;
+      log.times.push([performance.now(), name]);
+      if (log.times.length > 2048) log.times.shift();
+    };
+    const wrap = (proto, name, before) => {
+      const orig = proto && proto[name];
+      if (typeof orig !== 'function') return;
+      proto[name] = function (...args) {
+        try { before.call(this, args); } catch (e) {}
+        return orig.apply(this, args);
+      };
+    };
+    const started = function () {
+      note(this.context);
+      log.starts++;
+      if (this.loop === true) log.loops++;
+      const b = this.buffer;
+      if (b) { if (!ids.has(b)) ids.set(b, next++); cue('buffer#' + ids.get(b)); }
+      else cue(String(this.constructor && this.constructor.name || 'source').replace(/Node$/, '').toLowerCase());
+    };
+    // AudioBufferSourceNode declares its OWN start() (it takes an offset), so
+    // the base class's wrapper alone never sees a buffer play.
+    for (const C of [w.AudioScheduledSourceNode, w.AudioBufferSourceNode]) {
+      if (C && Object.prototype.hasOwnProperty.call(C.prototype, 'start')) wrap(C.prototype, 'start', started);
+    }
+    if (w.AudioNode) {
+      wrap(w.AudioNode.prototype, 'connect', function (args) {
+        note(this.context);
+        if (w.AudioDestinationNode && args[0] instanceof w.AudioDestinationNode) log.dest++;
+      });
+    }
+    const Ctx = w.AudioContext || w.webkitAudioContext;
+    if (Ctx) wrap(Ctx.prototype, 'resume', function () { note(this); log.resumes++; });
+    if (w.HTMLMediaElement) {
+      wrap(w.HTMLMediaElement.prototype, 'play', function () {
+        log.plays++;
+        if (this.loop === true) log.loops++;
+        const src = String(this.currentSrc || this.src || '');
+        cue(src ? (src.split(/[?#]/)[0].split('/').pop() || 'media') : 'media');
+      });
+    }
+    w.__FPX_AUDIO_LOG__ = log;
+    return 'installed';
+  } catch (e) { return 'failed'; }
+}

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

@@ -0,0 +1,141 @@
+// The sounds a game started, each with WHEN and WHAT, so a trailer can play
+// them back on the frames they happened on (lane S). a = { op: 'install' | 'drain' }.
+//
+// A sibling of audio.js (which counts starts for the probe and stays as it is):
+// this one keeps a timestamped log. 'install' must run BEFORE the game's code
+// (an init script), because it has to see where each AudioBuffer came from:
+// Response.arrayBuffer() and an arraybuffer XHR tag the bytes with their URL,
+// decodeAudioData() hands the tag on to the AudioBuffer it makes. Then every
+// Web Audio source start() and every HTMLMediaElement play() appends
+//   { t, kind, src, name, gain, rate, offset, duration, loop, state }
+// t = performance.now() when it sounds (start(when) in the future counts from
+// then) · kind = 'buffer' (a decoded file), 'made' (a buffer the page filled
+// itself), 'synth' (an oscillator or other source with no samples) or 'media'
+// · src = the file's URL, '' when there is none · gain = the product of every
+// GainNode on the first path to the speakers (0 = not connected, or muted),
+// or the element's volume · rate = playbackRate · offset/duration = start()'s
+// · loop = the source loops (a bed) · state = the context's state then.
+// At most 4000 kept. 'drain' returns the log and empties it, three-state:
+// `observed` false = nothing installed it.
+//
+// Part of @funpixel/verify: one function expression of one argument, loaded by
+// local `funtools trailer`. See mechanic_check.js for the calling convention.
+(a) => {
+  const w = window;
+  if (a && a.op === 'drain') {
+    const log = w.__FPX_AUDIO_CUES__;
+    if (!log || !Array.isArray(log.cues)) return JSON.stringify({ observed: false, cues: [] });
+    return JSON.stringify({ observed: true, dropped: log.dropped, cues: log.cues.splice(0, log.cues.length) });
+  }
+  try {
+    if (w.__FPX_AUDIO_CUES__) return 'already';
+    const log = { cues: [], dropped: 0 };
+    const from = new WeakMap(); // ArrayBuffer | AudioBuffer → URL
+    const outs = new WeakMap(); // AudioNode → the AudioNodes it feeds
+    const abs = (u) => { try { return new URL(String(u), location.href).href; } catch (e) { return String(u || ''); } };
+    const short = (u) => { try { return decodeURIComponent(new URL(u).pathname.split('/').pop()) || u; } catch (e) { return u; } };
+    const push = (c) => { if (log.cues.length >= 4000) { log.dropped++; return; } log.cues.push(c); };
+    const wrap = (proto, name, around) => {
+      const orig = proto && proto[name];
+      if (typeof orig !== 'function') return;
+      proto[name] = function (...args) { return around.call(this, orig, args); };
+    };
+
+    if (w.Response) {
+      wrap(w.Response.prototype, 'arrayBuffer', function (orig, args) {
+        const url = this.url;
+        const p = orig.apply(this, args);
+        return url ? p.then((ab) => { try { from.set(ab, abs(url)); } catch (e) {} return ab; }) : p;
+      });
+    }
+    if (w.XMLHttpRequest) {
+      wrap(w.XMLHttpRequest.prototype, 'open', function (orig, args) {
+        const url = abs(args[1]);
+        try {
+          this.addEventListener('load', () => {
+            try { const r = this.response; if (r instanceof ArrayBuffer) from.set(r, url); } catch (e) {}
+          });
+        } catch (e) {}
+        return orig.apply(this, args);
+      });
+    }
+    const Base = w.BaseAudioContext || w.AudioContext || w.webkitAudioContext;
+    if (Base) {
+      wrap(Base.prototype, 'decodeAudioData', function (orig, args) {
+        const url = args[0] && from.get(args[0]);
+        if (!url) return orig.apply(this, args);
+        const ok = args[1];
+        if (typeof ok === 'function') args[1] = function (buf) { try { from.set(buf, url); } catch (e) {} return ok.apply(this, arguments); };
+        const p = orig.apply(this, args);
+        return p && typeof p.then === 'function' ? p.then((buf) => { try { from.set(buf, url); } catch (e) {} return buf; }) : p;
+      });
+    }
+    if (w.AudioNode) {
+      wrap(w.AudioNode.prototype, 'connect', function (orig, args) {
+        try {
+          if (args[0] instanceof w.AudioNode) {
+            const list = outs.get(this) || [];
+            if (!list.includes(args[0])) list.push(args[0]);
+            outs.set(this, list);
+          }
+        } catch (e) {}
+        return orig.apply(this, args);
+      });
+    }
+    // The gain on the first path from `node` to the speakers; 0 when none reaches them.
+    const gainTo = (node, depth, seen) => {
+      if (w.AudioDestinationNode && node instanceof w.AudioDestinationNode) return 1;
+      if (depth > 16 || seen.has(node)) return 0;
+      seen.add(node);
+      const own = w.GainNode && node instanceof w.GainNode ? Number(node.gain.value) : 1;
+      for (const next of outs.get(node) || []) {
+        const g = gainTo(next, depth + 1, seen);
+        if (g > 0) return own * g;
+      }
+      return 0;
+    };
+    const round = (n) => Math.round(n * 1000) / 1000;
+
+    const started = function (orig, args) {
+      try {
+        const ctx = this.context;
+        const now = performance.now();
+        const when = Number(args[0]) || 0;
+        const lead = ctx && when > ctx.currentTime ? (when - ctx.currentTime) * 1000 : 0;
+        const b = this.buffer;
+        const src = b ? (from.get(b) || '') : '';
+        const kind = b ? (src ? 'buffer' : 'made') : 'synth';
+        const rate = this.playbackRate ? Number(this.playbackRate.value) || 1 : 1;
+        const name = src ? short(src) : String((this.constructor && this.constructor.name) || 'source').replace(/Node$/, '').toLowerCase();
+        push({
+          t: round(now + lead), kind, src, name, gain: round(gainTo(this, 0, new Set())), rate: round(rate),
+          offset: round(Number(args[1]) || 0), duration: args[2] === undefined ? null : round(Number(args[2]) || 0),
+          loop: this.loop === true, state: ctx ? String(ctx.state || '') : '',
+          seconds: b ? round(b.duration) : null,
+        });
+      } catch (e) {}
+      return orig.apply(this, args);
+    };
+    // AudioBufferSourceNode declares its OWN start(), so the base wrapper alone never sees a buffer play.
+    for (const C of [w.AudioScheduledSourceNode, w.AudioBufferSourceNode]) {
+      if (C && Object.prototype.hasOwnProperty.call(C.prototype, 'start')) wrap(C.prototype, 'start', started);
+    }
+    if (w.HTMLMediaElement) {
+      wrap(w.HTMLMediaElement.prototype, 'play', function (orig, args) {
+        try {
+          const raw = this.currentSrc || this.src || '';
+          const src = raw ? abs(raw) : '';
+          push({
+            t: round(performance.now()), kind: 'media', src, name: short(src) || 'media',
+            gain: round(this.muted ? 0 : Number(this.volume)), rate: round(Number(this.playbackRate) || 1),
+            offset: round(Number(this.currentTime) || 0), duration: null, loop: this.loop === true, state: '',
+            seconds: Number.isFinite(this.duration) ? round(this.duration) : null,
+          });
+        } catch (e) {}
+        return orig.apply(this, args);
+      });
+    }
+    w.__FPX_AUDIO_CUES__ = log;
+    return 'installed';
+  } catch (e) { return 'failed'; }
+}

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

@@ -0,0 +1,56 @@
+// Are the game's sound files real? Every audio file the page requested (the
+// resource timeline) or an <audio> names is fetched again and decoded. An
+// empty file, one with no samples, or one that will not decode fails.
+// a = { max, timeout_ms }
+// Returns JSON { observed, files, checked, broken: [..], skipped: [..] }:
+// broken names each file and why; skipped = not there (an error status, or
+// the host's HTML page answering a missing path),
+// cross-origin, a format this browser cannot decode (Chromium builds differ
+// on AAC), or a decode that timed out — not observed, never a failure.
+// Sorted, so runs compare.
+//
+// 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 AUDIO = /\.(mp3|ogg|oga|wav|m4a|aac|opus|flac|weba)(?:[?#]|$)/i;
+  const MIME = { mp3: 'audio/mpeg', ogg: 'audio/ogg', oga: 'audio/ogg', wav: 'audio/wav', m4a: 'audio/mp4',
+                 aac: 'audio/aac', opus: 'audio/ogg; codecs=opus', flac: 'audio/flac', weba: 'audio/webm' };
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+  const urls = new Set();
+  try { for (const e of performance.getEntriesByType('resource')) if (AUDIO.test(e.name)) urls.add(e.name.split('#')[0]); } catch (e) {}
+  for (const el of document.querySelectorAll('audio, audio source')) {
+    const s = el.currentSrc || el.src;
+    if (s && AUDIO.test(s)) urls.add(s.split('#')[0]);
+  }
+  const out = { observed: urls.size > 0, files: urls.size, checked: 0, broken: [], skipped: [] };
+  if (!urls.size) return JSON.stringify(out);
+  const name = (u) => { try { return decodeURIComponent(new URL(u, location.href).pathname.split('/').pop()) || u; } catch (e) { return u; } };
+  const Ctx = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+  const probe = document.createElement('audio');
+  for (const u of [...urls].sort().slice(0, a.max)) {
+    const ext = u.match(AUDIO)[1].toLowerCase();
+    let same = false;
+    try { same = new URL(u, location.href).origin === location.origin; } catch (e) {}
+    if (!same) { out.skipped.push(name(u) + ' (another origin)'); continue; }
+    if (!Ctx || !probe.canPlayType(MIME[ext] || '')) { out.skipped.push(name(u) + ' (this browser cannot decode .' + ext + ')'); continue; }
+    let res, buf;
+    try { res = await fetch(u, { cache: 'force-cache' }); buf = await res.arrayBuffer(); } catch (e) { out.skipped.push(name(u) + ' (could not fetch)'); continue; }
+    // A path that is not there is a MISSING file (smoke's static check owns
+    // those; a game may also look for an optional one), not a broken one —
+    // and a dev server or a preview host answers one with the page itself.
+    if (!res.ok) { out.skipped.push(name(u) + ' (HTTP ' + res.status + ', not there)'); continue; }
+    if (/^text\/html/i.test(res.headers.get('content-type') || '')) { out.skipped.push(name(u) + ' (the host answered with its page: not there)'); continue; }
+    out.checked++;
+    if (buf.byteLength === 0) { out.broken.push(name(u) + ' (empty file)'); continue; }
+    try {
+      const decoded = await Promise.race([new Ctx(1, 1, 44100).decodeAudioData(buf), sleep(a.timeout_ms).then(() => 'timeout')]);
+      if (decoded === 'timeout') { out.checked--; out.skipped.push(name(u) + ' (decode timed out)'); continue; }
+      if (!(decoded.duration > 0.01)) out.broken.push(name(u) + ' (no samples)');
+    } catch (e) {
+      out.broken.push(name(u) + ' (does not decode as audio)');
+    }
+  }
+  out.broken.sort(); out.skipped.sort();
+  return JSON.stringify(out);
+}

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

@@ -0,0 +1,72 @@
+// The bot sweep: a reflex bot presses the game's inputs for a while and reports
+// distinct states, score climb and the first failure. Read BEST-CASE, never
+// the average (see sweep_line).
+// a = { inputs, reaction_ms, sweep_ms }
+//
+// 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 raf = () => new Promise(r => requestAnimationFrame(r));
+  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+  const read = () => { try { return window.__FPX_STATE__(); } catch (e) { return null; } };
+  const inputs = a.inputs;
+  const REACT = a.reaction_ms; const TOTAL = a.sweep_ms;
+  const keyFor = (code) => (code.startsWith('Key') && code.length === 4) ? code[3].toLowerCase()
+    : (code.startsWith('Digit') && code.length === 6) ? code[5] : (code === 'Space' ? ' ' : code);
+  const press = async (inp) => {
+    if (inp.kind === 'key') {
+      const init = { key: keyFor(inp.code), code: inp.code, bubbles: true, cancelable: true };
+      const t = document.activeElement || document.body;
+      t.dispatchEvent(new KeyboardEvent('keydown', init)); await raf(); await sleep(Math.min(REACT, 250));
+      t.dispatchEvent(new KeyboardEvent('keyup', init));
+    } else if (inp.kind === 'pointer') {
+      const el = document.querySelector(inp.sel); if (!el) return false;
+      const r = el.getBoundingClientRect();
+      const init = { bubbles: true, cancelable: true, pointerId: 1, pointerType: 'touch', isPrimary: true,
+                     clientX: r.left + r.width / 2, clientY: r.top + r.height / 2, button: 0, buttons: 1 };
+      el.dispatchEvent(new PointerEvent('pointerdown', init)); await raf(); await sleep(Math.min(REACT, 250));
+      el.dispatchEvent(new PointerEvent('pointerup', { ...init, buttons: 0 }));
+    } else {
+      const v = (window.__FPX_VERBS__ || {})[inp.name]; if (typeof v !== 'function') return false; await v();
+    }
+    return true;
+  };
+  const s0 = read();
+  if (!s0 || typeof s0 !== 'object') return JSON.stringify({ ran: false });
+  const num = (o, k) => (o && typeof o[k] === 'number' && isFinite(o[k])) ? o[k] : null;
+  const keys = Object.keys(s0);
+  const scoreField = keys.find(k => /score|points|coins|gems|kills|distance|combo|wave|level|streak/i.test(k) && num(s0, k) !== null) || '';
+  const failField = keys.find(k => /lives|hp|health|shield|fuel|energy|time_?left|timer|remaining/i.test(k) && num(s0, k) !== null) || '';
+  const score0 = scoreField ? num(s0, scoreField) : null;
+  const fail0 = failField ? num(s0, failField) : null;
+  let prev = JSON.stringify(s0);
+  let windows = 0, softlock = 0, firstScore = -1, firstFail = -1;
+  // The per-press SERIES, kept rather than discarded: the score after
+  // every press, and a cheap digest of the whole state so repeated
+  // configurations can be counted without shipping the states back.
+  const scoreSeries = [], digests = [];
+  const digest = (str) => { let h = 5381; for (let i = 0; i < str.length; i++) h = ((h * 33) ^ str.charCodeAt(i)) >>> 0; return h; };
+  const t0 = performance.now();
+  let i = 0;
+  while (performance.now() - t0 < TOTAL) {
+    const inp = inputs[i++ % inputs.length];
+    let landed = false;
+    try { landed = await press(inp); } catch (e) { landed = false; }
+    await raf(); await sleep(REACT);
+    const s = read(); const now = JSON.stringify(s);
+    windows++;
+    if (landed && now === prev) softlock++;
+    if (firstScore < 0 && scoreField) { const v = num(s, scoreField); if (v !== null && score0 !== null && v > score0) firstScore = windows; }
+    if (firstFail < 0 && failField) { const v = num(s, failField); if (v !== null && fail0 !== null && v < fail0) firstFail = Math.round(performance.now() - t0); }
+    if (scoreField) { const v = num(s, scoreField); scoreSeries.push(v === null ? null : v); }
+    digests.push(digest(now));
+    prev = now;
+  }
+  // distinct states / presses: 1.0 = every press reached somewhere new,
+  // low = the same few configurations recur (Koster's exhausted pattern).
+  const distinct = new Set(digests).size;
+  return JSON.stringify({ ran: true, windows, softlock, firstScore, firstFail, scoreField, failField,
+                           distinct, scoreSeries });
+}
+