@funpixel/tools 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,501 @@
+// Motion is not animation (owner, 1 Oct, one game: "static people, static creatures; what is
+// animated is unlike living, just stone moves"). A sampler installed in the page watches the people,
+// creatures and the player and tells, per actor, whether anything INSIDE it changed: its picture (a
+// texture, a sheet frame, a UV offset), its bones, its morph weights, its vertices, or the pose of
+// its parts (a limb, a wing, a tail). Moving or turning the whole thing is not animation: a card that
+// travels with none of those changing "slides like a stone"; one that only bobs, tilts or turns in
+// place is "rigid". A person or creature that stays in place with nothing inside it changing has no
+// idle. Reactions: an actor that starts or stops moving, or changes its contract `state`, while the
+// player is within `react_m`: an actor REACTS when it changes more often per sample with the player
+// near than with the player far (a crab that always bobs changes at one rate everywhere; one that
+// scatters when the player comes changes more near). Counted per actor, not per change.
+//
+// Moving through space is not animating in place (one game's round 3: 28 townsfolk animated IN
+// PLACE, none walked anywhere): each actor says how far it travelled, and a crowd that never travels
+// is named. A crowd that wears the hero's face (the same geometry or texture as the player: rig
+// clones of the hero) and a crowd of one look are named too. Flyers (contract `flies`/`flying`, or a
+// flyer's name) are judged for a flap: a bird that only slides through the air glides like a stone.
+// Roles come from the actors contract's `node` names when it has them, else from the name words.
+//
+// A CUT-OUT is an actor whose every visible drawable is flat: a THREE.Sprite, or a mesh of a plane
+// or a small disc (≤ 8 vertices: a picture, a glow, a flat card); on Pixi a Sprite (anything with a texture and no mesh geometry).
+// A cut-out is judged as one: moving or bobbing the picture is motion; animation is a new picture
+// (a sheet frame), a bent plane (vertex version, morphs, bones), or two or more hinged parts whose pose
+// changes. A single cut-out's own pivot tilting is still one picture (rigid). A sway done in a vertex
+// shader cannot be read from the scene: declare it in the actors contract (`deform: true`). Mirroring
+// (scale.x sign) and opacity or tint pulses are never animation.
+//
+// A CODE-DRAWN shape (a Pixi Graphics cleared and drawn again each frame: one game's gulls flap and its
+// kite's tail streams that way) is read by what it draws: the drawing's size and its paths' points measured from
+// the drawing's own corner, so the same shape drawn at a new place is motion and a shape drawn
+// differently is animation. A Pixi mesh is read by its vertices. What the sampler cannot read inside (a
+// filter, a shader material, a drawing it cannot parse) makes an actor `unseen` when nothing else changed:
+// not observed, never "slides" or "no idle".
+//
+// The cycle while MOVING (the hero's walk, a walker's gait): the distinct pictures seen while moving
+// (cycle_frames), picture swaps while moving and while standing, the distance covered while moving,
+// and chunks of [metres, swaps, seconds] so a judge can tell a stride synced to ground speed (swaps per
+// metre steady as speed changes) from a timer (swaps per second steady), a treadmill (swaps while
+// standing) and a glide (no swaps while moving).
+//
+// Three and Pixi. Read-only: the sampler reads the scene every `every_ms` from a page timer.
+// Part of @funpixel/verify: one function expression of one argument. See mechanic_check.js for the
+// calling convention.
+//
+// a = { op: 'install', player, people, creatures: regex sources; every_ms (100); max (60); react_m (8) }
+//   | { op: 'read' }   (what was seen since install; the sampler keeps running)
+//   | { op: 'stop' }   (read, then remove the sampler)
+//   | { op: 'sample' } (one sample now: for tests and a caller that drives its own clock)
+//
+// Answers JSON (read/stop):
+//   engine — three | pixi | none; samples; ms
+//   actors — [{ name, role: player | person | creature, verdict: animated | slides | rigid | still,
+//               travelled (m or px), travels (bool: moved through space), frames (distinct pictures),
+//               deform (bool: bones, morphs, vertices or parts changed), idle (null when it travelled
+//               the whole time, else whether it was animated while in place), near_changes,
+//               far_changes, flies (bool), gait (the contract's gait preset name, when it names one),
+//               height (the contract's h or height, when given), look (a short id of its geometry + textures),
+//               hero (people only: null | 'geometry' | 'texture' | 'both': what it shares with the
+//               player's body, by content — a picture by its URL or pixel hash, a mesh by vertex count +
+//               bounding box + name — so the hero's file loaded twice still matches), hero_parts (the
+//               shared parts' names), cutout (bool), drawables, cycle_frames (distinct pictures while
+//               moving), swaps_moving, swaps_still, swaps_still_walk (standing swaps onto a
+//               picture of the moving cycle: a treadmill), moved_m (distance while moving), moving_s,
+//               chunks ([[m, swaps, s] per ~5 moving samples, at most 16]), shape_change (bool: bent,
+//               morphed or hinged while moving, beside picture swaps), unseen (true when nothing was seen to
+//               change and it holds something the sampler cannot read: a filter, a shader) }]
+//   crowd — { people, looks (distinct looks among the people), hero_clones (people sharing the
+//             player's geometry or texture) }
+//   reactions — { near (actors that react), far (actors that changed only at their own rate), actors (every name that reacts) }
+//   player_found
+(a) => {
+  const KEY = '__FPX_LIFE_ANIM__';
+  const op = (a && a.op) || 'install';
+  const w = window;
+  const summarize = (s) => {
+    const out = { engine: s.engine, samples: s.samples, ms: Math.round(performance.now() - s.t0), actors: [], reactions: { near: 0, far: 0, actors: [] }, crowd: { people: 0, looks: 0, hero_clones: 0 }, player_found: s.playerFound };
+    // What the hero is made of, read now (its model may have loaded after install): body parts only.
+    let hero = null;
+    for (const [o, t] of s.tracks) if (t.role === 'player') { hero = (s.bodyOf && s.bodyOf(o)) || null; break; }
+    const looks = new Set();
+    for (const [o, t] of s.tracks) {
+      const deform = t.pictures.size > 1 || t.deform;
+      const moved = t.travel > s.travelEps;
+      const verdict = deform ? 'animated' : moved ? 'slides' : t.rigid ? 'rigid' : 'still';
+      const idle = t.inPlace >= 3 ? deform || t.idleDeform : null;
+      // Only PEOPLE are judged for the hero's face: a moth sharing the hero's glow texture is not a clone.
+      let shares = null, parts = [];
+      if (hero && t.role === 'person' && s.bodyOf) {
+        const mine = s.bodyOf(o);
+        if (mine) { const c = s.compare(hero, mine); shares = c.shares; parts = c.parts; }
+      }
+      const look = t.looks ? `${t.looks.geo.join('+')}/${t.looks.tex.join('+')}`.slice(0, 80) : '';
+      if (t.role === 'person') { out.crowd.people++; if (look) looks.add(look); if (shares) out.crowd.hero_clones++; }
+      const r2 = (v) => Math.round(v * 100) / 100;
+      const chunks = t.chunks.slice(0, 16).map((c) => [r2(c[0]), c[1], r2(c[2])]);
+      if (t.chunk[3] >= 2 && chunks.length < 16) chunks.push([r2(t.chunk[0]), t.chunk[1], r2(t.chunk[2])]);
+      out.actors.push({ name: t.name, role: t.role, verdict, travelled: Math.round(t.travel * 100) / 100, travels: moved, frames: t.pictures.size, deform, idle, near_changes: t.near, far_changes: t.far, flies: !!t.flies, ...(t.gait ? { gait: t.gait } : {}), ...(t.height ? { height: t.height } : {}), look, hero: shares, ...(parts.length ? { hero_parts: parts } : {}),
+        cutout: !!t.cutout, drawables: t.drawables, ...(t.unseen && !deform ? { unseen: true } : {}), cycle_frames: t.movePics.size, swaps_moving: t.swapsMoving, swaps_still: t.swapsStill, swaps_still_walk: t.swapsStillWalk, moved_m: r2(t.moveDist), moving_s: r2(t.moveSecs), chunks, shape_change: !!t.shapeMoving });
+      const nearRate = t.nearN ? t.near / t.nearN : 0, farRate = t.farN ? t.far / t.farN : 0;
+      const reacts = t.near >= 1 && nearRate > 2 * farRate;
+      if (reacts) { out.reactions.near++; out.reactions.actors.push(t.name); }
+      else if (t.near + t.far > 0) out.reactions.far++;
+    }
+    out.crowd.looks = looks.size;
+    return JSON.stringify(out);
+  };
+  if (op === 'sample') {
+    const s = w[KEY];
+    if (s && s.sample) { try { s.sample(); } catch (e) { /* mid-rebuild */ } }
+    return JSON.stringify({ sampled: !!(s && s.sample), samples: s ? s.samples : 0 });
+  }
+  if (op === 'read' || op === 'stop') {
+    const s = w[KEY];
+    if (!s) return JSON.stringify({ engine: 'none', samples: 0, ms: 0, actors: [], reactions: { near: 0, far: 0, actors: [] }, player_found: false, error: 'not installed' });
+    if (op === 'stop') { clearInterval(s.timer); delete w[KEY]; }
+    return summarize(s);
+  }
+  if (w[KEY]) { clearInterval(w[KEY].timer); delete w[KEY]; }
+
+  const EVERY = a.every_ms || 100, MAX = a.max || 60, REACT = a.react_m || 8;
+  const pat = {
+    player: new RegExp(a.player || 'player|hero|avatar', 'i'),
+    person: new RegExp(a.people || 'person|people|folk|npc|villager|townsperson|guard|man\\b|woman|child|kid|worker|vendor|keeper', 'i'),
+    creature: new RegExp(a.creatures || 'creature|animal|beast|monster|crab|bird|fox|dog|hound|cat|fish|moth|goat|wader|wolf|bug|insect|critter|horse|cow|sheep|gull|kite|bat\\b|owl|crow|deer|rabbit|duck|chicken|pig\\b|butterfl', 'i'),
+  };
+  const FLYER = /bird|kite|gull|moth|bat\b|crow|owl|butterfl|wing|flyer|flier|swallow|hawk|eagle|dragonfl|bee\b/i;
+  // The actors contract: node name → kind and whether it flies (roles by contract before name words).
+  const contract = new Map();
+  try {
+    const f = w.__FPX_ACTORS__;
+    const got = typeof f === 'function' ? f() : f;
+    const list = got && Array.isArray(got.actors) ? got.actors : Array.isArray(got) ? got : [];
+    for (const x of list) {
+      if (!x || typeof x.node !== 'string' || !x.node) continue;
+      const k = String(x.kind ?? '');
+      const kind = k === 'player' ? 'player' : k === 'person' || /folk|npc|villager|towns|human|crowd|worker/i.test(k) ? 'person' : k === 'creature' || pat.creature.test(k) ? 'creature' : null;
+      if (kind) contract.set(x.node, { kind, flies: x.flies === true || x.flying === true, deform: x.deform === true || x.deforms === true, gait: typeof x.gait === 'string' ? x.gait.slice(0, 24) : null, height: [x.height, x.h].find((v) => typeof v === 'number' && v > 0) ?? null });
+    }
+  } catch (e) { /* no contract: names only */ }
+  const roleOf = (n) => (!n ? null : contract.has(n) ? contract.get(n).kind : pat.player.test(n) ? 'player' : pat.person.test(n) ? 'person' : pat.creature.test(n) ? 'creature' : null);
+  const declared = (n, k) => (contract.has(n) ? contract.get(n)[k] : null);
+  const fliesOf = (n) => (contract.has(n) ? contract.get(n).flies : false) || FLYER.test(n);
+  // What a body is made of: its geometries and the sources of its textures (a clone of the hero's
+  // rig shares both; recolouring the material keeps the texture). `looksOf` tells people apart by object
+  // identity (the crowd's distinct looks); `bodyOf` compares with the hero by CONTENT, so a second load
+  // of the same file (the hero's GLB loaded again for the crowd: new uuids, same body) still matches.
+  const texId = (t) => (!t ? '' : String((t.source && t.source.uuid) || (t.image && (t.image.currentSrc || t.image.src)) || t.uid || t.uuid || t.label || '').split('/').pop().slice(-24));
+  const looksOf = (o) => {
+    const geo = new Set(), tex = new Set();
+    const visit = (n, depth) => {
+      if (!n || depth > 8 || geo.size + tex.size > 24) return;
+      if (pixi) { const t = n.texture; const src = t && (t.source || t.baseTexture); const id = texId(src) || texId(t); if (id) tex.add(id); }
+      else {
+        if (n.geometry && n.geometry.uuid && (n.isMesh || n.isSkinnedMesh)) geo.add(String(n.geometry.uuid).slice(0, 8));
+        const ms = Array.isArray(n.material) ? n.material : n.material ? [n.material] : [];
+        for (const m of ms) { const id = texId(m.map); if (id) tex.add(id); }
+      }
+      for (const c of n.children || []) visit(c, depth + 1);
+    };
+    visit(o, 0);
+    return geo.size || tex.size ? { geo: [...geo].sort(), tex: [...tex].sort() } : null;
+  };
+  // An image's identity: its URL when it has a real one (a blob: or data: URL differs per load), else
+  // its size and an 8×8 pixel hash (the same picture decoded twice hashes the same), else size + name.
+  const imgIds = new WeakMap();
+  const imageId = (img, name) => {
+    if (!img || typeof img !== 'object') return '';
+    if (imgIds.has(img)) return imgIds.get(img);
+    let id = '';
+    const src = String(img.currentSrc || img.src || '');
+    if (src && !/^(blob|data):/.test(src)) id = `url:${src.split('?')[0].split('/').pop()}`;
+    const W = img.width || img.naturalWidth || img.displayWidth || 0, H = img.height || img.naturalHeight || img.displayHeight || 0;
+    if (!id && W && H) {
+      try {
+        const doc = w.document;
+        const c = doc && doc.createElement ? doc.createElement('canvas') : null;
+        const g = c && c.getContext && c.getContext('2d', { willReadFrequently: true });
+        if (g) {
+          c.width = 8; c.height = 8;
+          g.drawImage(img, 0, 0, 8, 8);
+          const d = g.getImageData(0, 0, 8, 8).data;
+          let h = 2166136261;
+          for (let i = 0; i < d.length; i++) { h ^= d[i] >> 3; h = Math.imul(h, 16777619) >>> 0; }
+          id = `px:${W}x${H}:${h.toString(16)}`;
+        }
+      } catch (e) { /* tainted or not drawable */ }
+      if (!id && name) id = `name:${W}x${H}:${name}`;
+    }
+    imgIds.set(img, id);
+    return id;
+  };
+  const texContent = (t) => {
+    if (!t) return '';
+    if (pixi) { const src = t.source || t.baseTexture || null; const img = src && ((src.resource && (src.resource.source || src.resource)) || src.image); return imageId(img, src && src.label) || texId(src) || texId(t); }
+    const img = t.image || (t.source && t.source.data) || null;
+    return imageId(img, t.name || (img && img.name) || '');
+  };
+  // A geometry's signature: vertex count, its bounding box (to the centimetre) and the mesh's name.
+  const geoSigs = new WeakMap();
+  const geoSig = (n) => {
+    const g = n.geometry, pos = g && g.attributes && g.attributes.position;
+    if (!pos || !pos.count) return null;
+    if (geoSigs.has(g)) return { ...geoSigs.get(g), name: String(n.name || '') };
+    const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+    const arr = pos.array, k = pos.itemSize || 3, step = Math.max(1, Math.floor(pos.count / 4000));
+    if (arr && !pos.isInterleavedBufferAttribute) {
+      for (let i = 0; i < pos.count; i += step) for (let j = 0; j < 3; j++) { const v = arr[i * k + j]; if (v < lo[j]) lo[j] = v; if (v > hi[j]) hi[j] = v; }
+    }
+    const box = Number.isFinite(lo[0]) ? lo.concat(hi).map((v) => Math.round(v * 100) / 100) : null;
+    const sig = { count: pos.count, box };
+    geoSigs.set(g, sig);
+    return { ...sig, name: String(n.name || '') };
+  };
+  // The parts a body is made of that could carry a face: skinned meshes and meshes of 300+ vertices
+  // (a glow disc, a pip or a shadow card is not a body), with their pictures; Pixi: every sprite's picture.
+  const bodyOf = (o) => {
+    const parts = [];
+    const visit = (n, depth) => {
+      if (!n || depth > 10 || parts.length > 32 || n.visible === false) return;
+      if (pixi) { const id = texContent(n.texture); if (id) parts.push({ name: String(n.label || n.name || ''), geo: null, tex: [id] }); }
+      else if (n.isMesh || n.isSkinnedMesh) {
+        const sig = geoSig(n);
+        if (sig && (n.isSkinnedMesh || sig.count >= 300)) {
+          const ms = Array.isArray(n.material) ? n.material : n.material ? [n.material] : [];
+          const tex = ms.map((m) => texContent(m && m.map)).filter(Boolean);
+          parts.push({ name: String(n.name || (ms[0] && ms[0].name) || ''), geo: sig, tex });
+        }
+      }
+      for (const c of n.children || []) visit(c, depth + 1);
+    };
+    visit(o, 0);
+    return parts.length ? parts : null;
+  };
+  const sameGeo = (a, b) => !!a && !!b && a.count === b.count && ((!!a.name && a.name === b.name) || (!!a.box && !!b.box && a.box.every((v, i) => Math.abs(v - b.box[i]) <= 0.02 + 0.03 * Math.abs(v))));
+  // What a person shares with the hero, by content, and the hero's parts it wears (by name).
+  const compare = (hero, mine) => {
+    let g = false, x = false;
+    const parts = new Set();
+    for (const p of mine) for (const h of hero) {
+      const geo = sameGeo(h.geo, p.geo), tex = p.tex.some((t) => h.tex.includes(t));
+      if (geo) g = true;
+      if (tex) x = true;
+      if ((geo || tex) && (h.name || p.name)) parts.add(h.name || p.name);
+    }
+    return { shares: g && x ? 'both' : g ? 'geometry' : x ? 'texture' : null, parts: [...parts].slice(0, 4) };
+  };
+  const app = w.__PIXI_APP__ || (w.__PIXI_DEVTOOLS__ && w.__PIXI_DEVTOOLS__.app) || null;
+  const stage = (app && app.stage) || w.__PIXI_STAGE__ || null;
+  const scene = w.__THREEJS_SCENE__ || (w.scene && w.scene.isScene ? w.scene : null);
+  const pixi = !!(stage && Array.isArray(stage.children));
+  const three = !pixi && !!(scene && scene.isObject3D);
+  const s = { engine: pixi ? 'pixi' : three ? 'three' : 'none', samples: 0, t0: performance.now(), tracks: new Map(), playerFound: false, travelEps: three ? 0.25 : 6, timer: 0 };
+  s.bodyOf = bodyOf; s.compare = compare;
+  w[KEY] = s;
+  if (!pixi && !three) return JSON.stringify({ installed: false, engine: 'none' });
+  const EPS = 0.002;
+
+  const picture = (o) => {
+    if (pixi) { const t = o.texture; if (!t || typeof t === 'function') return ''; const f = t.frame || {}; return `${t.uid ?? t.label ?? ''}:${f.x},${f.y},${f.width},${f.height}`; }
+    const m = o.material && !Array.isArray(o.material) ? o.material : null;
+    const t = m && m.map;
+    return t ? `${t.uuid}:${t.offset ? `${t.offset.x.toFixed(3)},${t.offset.y.toFixed(3)}` : ''}:${t.repeat ? `${t.repeat.x.toFixed(3)},${t.repeat.y.toFixed(3)}` : ''}` : '';
+  };
+  // A code-drawn Pixi shape (Graphics, redrawn each frame: a gull's wings, a streaming tail, a paper sail that
+  // bellies; one game, 9 Oct) is read by what it draws, not by a picture: its drawing's size and every path's
+  // points measured from the drawing's own corner, so a shape drawn again at a new place reads the same (that
+  // is motion) and a shape drawn differently reads as changed (that is animation). Pixi v8 (context
+  // instructions), v7 (geometry.graphicsData); null when neither can be read.
+  const isGraphics = (n) => pixi && !!n && (n.renderPipeId === 'graphics' || !!(n.context && Array.isArray(n.context.instructions)) || !!(n.geometry && Array.isArray(n.geometry.graphicsData)));
+  const COORDS = { moveTo: 2, lineTo: 2, quadraticCurveTo: 4, bezierCurveTo: 6, arcTo: 4, arc: 2, circle: 2, ellipse: 2, rect: 2, roundRect: 2, regularPoly: 2, roundPoly: 2, roundShape: 0, filletRect: 2, chamferRect: 2, star: 2 };
+  const half = (v) => Math.round(v * 2) / 2;
+  const shapeOf = (n) => {
+    try {
+      let h = 2166136261, k = 0;
+      const mix = (v) => { h ^= (Math.round(v * 2) | 0) & 0xffff; h = Math.imul(h, 16777619) >>> 0; k++; };
+      const ctx = n.context;
+      if (ctx && Array.isArray(ctx.instructions)) {
+        const b = ctx.bounds || {};
+        const ox = Number.isFinite(b.minX) ? b.minX : 0, oy = Number.isFinite(b.minY) ? b.minY : 0;
+        const out = [Number.isFinite(b.maxX) ? half(b.maxX - ox) : 0, Number.isFinite(b.maxY) ? half(b.maxY - oy) : 0, ctx.instructions.length];
+        for (const ins of ctx.instructions.slice(0, 32)) {
+          const path = ins && ins.data && ins.data.path;
+          for (const p of (path && Array.isArray(path.instructions) ? path.instructions : []).slice(0, 64)) {
+            if (k > 600) break;
+            const d = Array.isArray(p && p.data) ? p.data : [];
+            if (p.action === 'poly' || p.action === 'addPath' || Array.isArray(d[0])) {
+              const pts = Array.isArray(d[0]) ? d[0] : [];
+              for (let i = 0; i < pts.length && k <= 600; i++) { const q = pts[i]; if (typeof q === 'number') mix(q - (i % 2 ? oy : ox)); else if (q && typeof q.x === 'number') { mix(q.x - ox); mix(q.y - oy); } }
+              continue;
+            }
+            const c = COORDS[p.action] ?? 0;
+            for (let i = 0; i < d.length; i++) if (typeof d[i] === 'number') mix(i < c ? d[i] - (i % 2 ? oy : ox) : d[i]);
+          }
+        }
+        out.push(h, k);
+        return out;
+      }
+      const gd = n.geometry && n.geometry.graphicsData;
+      if (Array.isArray(gd)) {
+        const lb = typeof n.getLocalBounds === 'function' ? n.getLocalBounds() : null;
+        const ox = lb ? lb.x : 0, oy = lb ? lb.y : 0;
+        for (const item of gd.slice(0, 64)) {
+          const s = item && item.shape;
+          if (!s) continue;
+          if (Array.isArray(s.points)) s.points.slice(0, 400).forEach((v, i) => mix(v - (i % 2 ? oy : ox)));
+          else for (const key of ['x', 'y', 'width', 'height', 'radius', 'halfWidth', 'halfHeight']) if (typeof s[key] === 'number') mix(key === 'x' ? s[key] - ox : key === 'y' ? s[key] - oy : s[key]);
+        }
+        return [lb ? half(lb.width) : 0, lb ? half(lb.height) : 0, gd.length, h, k];
+      }
+    } catch (e) { /* a context mid-rebuild */ }
+    return null;
+  };
+  // A Pixi mesh (a rope tail, a bent plane): its vertices measured from the first one.
+  const meshOf = (n) => {
+    const g = n.geometry;
+    const pos = g && (g.positions || (g.attributes && g.attributes.aPosition && g.attributes.aPosition.buffer && g.attributes.aPosition.buffer.data));
+    if (!pos || typeof pos.length !== 'number' || pos.length < 4) return null;
+    let h = 2166136261;
+    const step = Math.max(2, 2 * Math.floor(pos.length / 512));
+    for (let i = 0; i + 1 < pos.length; i += step) for (let j = 0; j < 2; j++) { h ^= (Math.round((pos[i + j] - pos[j]) * 2) | 0) & 0xffff; h = Math.imul(h, 16777619) >>> 0; }
+    return h;
+  };
+  // Drawn in a way the sampler cannot read inside: a Pixi filter that moves pixels (a displacement map: a flag's
+  // wave, water; a colour or glow filter moves nothing), a shader material (a vertex sway), a code-drawn shape
+  // whose drawing is not readable. Its animation is not observed.
+  const displaces = (f) => !!f && (!!(f.sprite || f._sprite || f.displacementMap) || /displac|wave|shockwave|twist|bulge|reflection/i.test(String((f.constructor && f.constructor.name) || '')));
+  const unreadable = (n) => (pixi ? (Array.isArray(n.filters) && n.filters.some(displaces)) || (isGraphics(n) && !shapeOf(n))
+    : !!(n.material && (n.material.isShaderMaterial || n.material.isRawShaderMaterial || (Array.isArray(n.material) && n.material.some((m) => m && (m.isShaderMaterial || m.isRawShaderMaterial))))));
+  // What is inside: the parts' local pose, bones, morph weights, vertex versions, pictures, drawn shapes.
+  const inside = (o, parts = true) => {
+    const nums = [];
+    const pics = [picture(o)];
+    let opaque = false;
+    const own = (n) => {
+      if (unreadable(n)) opaque = true;
+      if (pixi && isGraphics(n)) { const sh = shapeOf(n); if (sh) nums.push(...sh); }
+      else if (pixi && n.geometry) { const m = meshOf(n); if (m !== null) nums.push(m); }
+      if (n.skeleton && Array.isArray(n.skeleton.bones)) {
+        for (let i = 0; i < n.skeleton.bones.length && i < 64; i++) { const q = n.skeleton.bones[i].quaternion; nums.push(q.x, q.y, q.z, q.w); }
+      }
+      if (Array.isArray(n.morphTargetInfluences)) nums.push(...n.morphTargetInfluences.slice(0, 32));
+      const g = n.geometry;
+      if (g && g.attributes && g.attributes.position) nums.push(g.attributes.position.version || 0);
+    };
+    own(o);
+    const walk = (n, depth) => {
+      if (depth > 8) return;
+      for (const c of n.children || []) {
+        if (c.visible === false) continue;
+        // Opacity and tint are never animation; a mirror flip (scale.x sign) is a turn, not a pose.
+        if (!parts) { /* one flat picture: its own pivot moving is the whole picture moving */ }
+        else if (pixi) nums.push(c.x || 0, c.y || 0, Math.abs(c.scale?.x ?? 1), c.scale?.y ?? 1, c.rotation ?? 0);
+        else if (!c.isBone) { const q = c.quaternion || {}, p = c.position || {}; nums.push(p.x ?? 0, p.y ?? 0, p.z ?? 0, q.x ?? 0, q.y ?? 0, q.z ?? 0, q.w ?? 1); }
+        pics.push(picture(c));
+        own(c);
+        walk(c, depth + 1);
+      }
+    };
+    walk(o, 0);
+    return { nums, pic: pics.join('|'), opaque };
+  };
+  const rigidOf = (o) => (pixi ? [Math.abs(o.scale?.x ?? 1), o.scale?.y ?? 1, o.rotation ?? 0, o.skew?.x ?? 0, o.skew?.y ?? 0]
+    : [Math.abs(o.scale?.x ?? 1), o.scale?.y ?? 1, o.scale?.z ?? 1, o.rotation?.x ?? 0, o.rotation?.z ?? 0, o.position?.y ?? 0]);
+  const where = (o) => {
+    if (pixi) { try { const p = o.getGlobalPosition(); return [p.x, 0, p.y]; } catch (e) { return [o.x || 0, 0, o.y || 0]; } }
+    const e = o.matrixWorld.elements;
+    return [e[12], e[13], e[14]];
+  };
+  // Flat drawables: a sprite, or a plane or small disc (≤ 8 vertices); a skinned or real mesh is not flat.
+  const flatness = (o) => {
+    let all = 0, flat = 0;
+    const visit = (n, depth) => {
+      if (!n || depth > 10 || n.visible === false || all > 64) return;
+      if (pixi) {
+        // A code-drawn shape is vector work, never a painted picture (a Graphics' texture() is a drawing method).
+        if (isGraphics(n)) all++;
+        else if (n.texture && typeof n.texture !== 'function' && !(n.geometry || n.vertices)) { all++; flat++; } else if (n.geometry || n.vertices) all++;
+      } else if (n.isSprite) { all++; flat++; }
+      else if (n.isSkinnedMesh) all++;
+      else if (n.isMesh) {
+        const pos = n.geometry && n.geometry.attributes && n.geometry.attributes.position;
+        all++;
+        if (pos && pos.count <= 8) flat++; // a quad or a small disc: a picture, a glow or a flat card
+      }
+      for (const c of n.children || []) visit(c, depth + 1);
+    };
+    visit(o, 0);
+    return { drawables: all, cutout: all > 0 && flat === all };
+  };
+  const differs = (x, y) => x.length !== y.length || x.some((v, i) => Math.abs(v - y[i]) > EPS);
+  const stateOf = () => {
+    try {
+      const f = w.__FPX_ACTORS__;
+      const got = typeof f === 'function' ? f() : f;
+      const list = got && Array.isArray(got.actors) ? got.actors : Array.isArray(got) ? got : null;
+      const m = new Map();
+      if (list) for (const x of list) if (x && x.node && x.state !== undefined && x.state !== null) m.set(String(x.node), String(x.state));
+      return m;
+    } catch (e) { return new Map(); }
+  };
+
+  const below = new WeakMap();
+  const playerBelow = (o) => {
+    if (below.has(o)) return below.get(o);
+    let hit = false;
+    const look = (n, depth) => {
+      if (hit || !n || depth > 6) return;
+      for (const c of n.children || []) { if (roleOf(c.label || c.name || '') === 'player') { hit = true; return; } look(c, depth + 1); }
+    };
+    look(o, 0);
+    below.set(o, hit);
+    return hit;
+  };
+  const sample = () => {
+    if (three && scene.updateMatrixWorld) scene.updateMatrixWorld();
+    const found = [];
+    let player = null;
+    const walk = (o, depth) => {
+      if (!o || o.visible === false || depth > 14) return;
+      if (pixi && (o.alpha ?? 1) <= 0.01) return;
+      const name = o.label || o.name || '';
+      const role = roleOf(name);
+      // A node named like a creature that holds the player (one game: the "kite" container around the player's
+      // sail, a kite also being a flyer's word) is not an actor: the player inside it is looked for.
+      if (role && !(role !== 'player' && playerBelow(o))) {
+        found.push([o, role, name]);
+        return;
+      }
+      for (const c of o.children || []) walk(c, depth + 1);
+    };
+    walk(pixi ? stage : scene, 0);
+    // Several nodes answer to the player's name (the hero's rig cloned for a crowd): the player is
+    // the one the contract puts at the player's feet (else the first); the rest are people.
+    const named = found.filter((f) => f[1] === 'player');
+    if (named.length) {
+      s.playerFound = true;
+      if (s.playerNode && named.some((f) => f[0] === s.playerNode)) player = s.playerNode;
+      else {
+        let me = null;
+        try { const f = w.__FPX_ACTORS__; const got = typeof f === 'function' ? f() : f; const list = got && Array.isArray(got.actors) ? got.actors : Array.isArray(got) ? got : []; me = list.find((x) => x && x.kind === 'player') || null; } catch (e) { /* none */ }
+        player = named[0][0];
+        if (me && named.length > 1 && typeof me.x === 'number') {
+          let best = Infinity;
+          for (const [o] of named) { const p = where(o); const d = Math.hypot(p[0] - me.x, p[2] - (me.z ?? 0)); if (d < best) { best = d; player = o; } }
+        }
+        s.playerNode = player;
+      }
+      for (const f of named) if (f[0] !== player) f[1] = 'person';
+    }
+    const pAt = player ? where(player) : null;
+    const states = stateOf();
+    for (const [o, role, name] of found) {
+      let t = s.tracks.get(o);
+      if (!t) {
+        if (s.tracks.size >= MAX) continue;
+        const fl = flatness(o);
+        t = { name, role, cutout: fl.cutout, drawables: fl.drawables, movePics: new Set(), swapsMoving: 0, swapsStill: 0, swapsStillWalk: 0, moveDist: 0, moveSecs: 0, chunk: [0, 0, 0, 0], chunks: [], shapeMoving: false, declaredDeform: !!declared(name, 'deform'), lastT: performance.now(), first: null, last: null, pictures: new Set(), deform: false, idleDeform: false, rigid: false, travel: 0, inPlace: 0, moving: null, state: null, near: 0, far: 0, nearN: 0, farN: 0, flies: fliesOf(name), gait: declared(name, 'gait'), height: declared(name, 'height'), looks: looksOf(o) };
+        s.tracks.set(o, t);
+      }
+      t.role = role;
+      // A lone flat picture: its pivot moving is the picture moving (rigid), not a pose.
+      const at = where(o), ins = inside(o, !(t.cutout && t.drawables <= 1)), rig = rigidOf(o);
+      if (!t.first) { t.first = { at, ins, rig }; t.last = { at, ins }; }
+      const step = Math.hypot(at[0] - t.last.at[0], at[2] - t.last.at[2]);
+      t.travel += step;
+      t.pictures.add(ins.pic);
+      if (ins.opaque) t.unseen = true;
+      const swapped = ins.pic !== t.last.ins.pic, shaped = differs(ins.nums, t.last.ins.nums);
+      const changed = shaped || swapped || t.declaredDeform;
+      if (changed) t.deform = true;
+      if (differs(rig, t.first.rig)) t.rigid = true;
+      const moving = step > (three ? 0.01 : 0.5);
+      if (!moving) { t.inPlace++; if (changed) t.idleDeform = true; }
+      // The cycle while moving: pictures, swaps per metre in chunks of ~5 moving samples.
+      const now = performance.now(), dt = Math.max(0, (now - t.lastT) / 1000);
+      t.lastT = now;
+      if (moving) {
+        t.movePics.add(ins.pic);
+        if (swapped) t.swapsMoving++;
+        if (shaped) t.shapeMoving = true;
+        t.moveDist += step; t.moveSecs += dt;
+        t.chunk[0] += step; t.chunk[1] += swapped ? 1 : 0; t.chunk[2] += dt; t.chunk[3]++;
+        if (t.chunk[3] >= 5) { if (t.chunks.length < 64) t.chunks.push(t.chunk.slice(0, 3)); t.chunk = [0, 0, 0, 0]; }
+      } else if (swapped) { t.swapsStill++; if (t.movePics.has(ins.pic)) t.swapsStillWalk++; }
+      // A reaction: starting or stopping, or a new contract state, with the player near or far.
+      const st = states.get(name) ?? null;
+      const flipped = (t.moving !== null && moving !== t.moving) || (t.state !== null && st !== null && st !== t.state);
+      if (role !== 'player' && pAt) {
+        const close = Math.hypot(at[0] - pAt[0], at[2] - pAt[2]) <= (three ? REACT : REACT * 40);
+        if (close) { t.nearN++; if (flipped) t.near++; } else { t.farN++; if (flipped) t.far++; }
+      }
+      t.moving = moving; t.state = st;
+      t.last = { at, ins };
+    }
+    s.samples++;
+  };
+  s.sample = sample;
+  sample();
+  s.timer = setInterval(() => { try { sample(); } catch (e) { /* a scene mid-rebuild */ } }, EVERY);
+  return JSON.stringify({ installed: true, engine: s.engine });
+}

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

@@ -0,0 +1,83 @@
+// What the drawn Three.js objects are made of (`funtools look --3d`, the live half): each mesh
+// in view by its geometry's class — a primitive three builds from numbers (Box, Cylinder, …) or a
+// buffer (a loaded model, or a mesh built vertex by vertex) — skinned or not, textured or not,
+// its triangles, and the share of the screen its bounds cover. Grouped two ways: the hero nodes
+// (a name matching the hero pattern, the outermost such ancestor owning the mesh) and the scene's
+// top-level nodes, largest on screen first. Read-only (Three may cache a bounding box).
+//
+// Part of @funpixel/verify: one function expression of one argument. See
+// mechanic_check.js for the calling convention.
+//
+// a = { heroes: regex source for hero node names, max: groups listed }
+//
+// Answers JSON:
+//   engine  — three | none
+//   heroes  — [{ name, meshes, primitive, types { Box: n }, buffer, skinned, textured, tris, share }]
+//   top     — the same for the scene's top-level nodes, by share, at most `max`
+//   totals  — the same summed over every mesh in view
+//   error   — why nothing was read
+async (a) => {
+  const MAX = a.max || 8;
+  const HERO = new RegExp(a.heroes || 'player|hero|rival|enemy|boss|opponent|vehicle|kart|car|ship|boat|character', 'i');
+  const out = { engine: 'none', heroes: [], top: [], totals: null, error: '' };
+  const scene = window.__THREEJS_SCENE__ || (window.scene && window.scene.isScene ? window.scene : null);
+  const cam = window.camera || window.__THREEJS_CAMERA__ || null;
+  const T = window.THREE;
+  if (!scene || !scene.isObject3D) { out.error = 'no Three scene (window.__THREEJS_SCENE__)'; return JSON.stringify(out); }
+  out.engine = 'three';
+  if (!cam || !cam.isCamera || !T || !T.Box3 || !T.Vector3) { out.error = 'no camera or THREE on window: counts without screen share'; }
+  const empty = (name) => ({ name, meshes: 0, primitive: 0, types: {}, buffer: 0, skinned: 0, textured: 0, tris: 0, share: 0 });
+  const heroes = new Map(), top = new Map(), totals = empty('all');
+  const box = T && T.Box3 ? new T.Box3() : null, v = T && T.Vector3 ? new T.Vector3() : null;
+  cam && cam.updateMatrixWorld && cam.updateMatrixWorld();
+  const shareOf = (o) => {
+    if (!box || !v || !cam || !cam.isCamera) return 0;
+    try { box.setFromObject(o); } catch (e) { return 0; }
+    if (box.isEmpty()) return 0;
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity, front = 0;
+    for (let i = 0; i < 8; i++) {
+      v.set(i & 1 ? box.max.x : box.min.x, i & 2 ? box.max.y : box.min.y, i & 4 ? box.max.z : box.min.z).project(cam);
+      if (v.z < 1) front++;
+      x0 = Math.min(x0, v.x); y0 = Math.min(y0, v.y); x1 = Math.max(x1, v.x); y1 = Math.max(y1, v.y);
+    }
+    if (!front) return 0;
+    const w = Math.max(0, Math.min(1, x1) - Math.max(-1, x0)), h = Math.max(0, Math.min(1, y1) - Math.max(-1, y0));
+    return (w * h) / 4;
+  };
+  const add = (g, m, share) => {
+    const geo = m.geometry || {};
+    const type = String(geo.type || '');
+    const prim = /Geometry$/.test(type) && !/^(Instanced)?BufferGeometry$/.test(type);
+    const pos = geo.attributes && geo.attributes.position;
+    const tris = Math.round(((geo.index ? geo.index.count : pos ? pos.count : 0) / 3) * (m.isInstancedMesh ? m.count || 1 : 1));
+    const mats = Array.isArray(m.material) ? m.material : m.material ? [m.material] : [];
+    g.meshes++;
+    if (prim) { g.primitive++; const k = type.replace(/(Buffer)?Geometry$/, ''); g.types[k] = (g.types[k] || 0) + 1; } else g.buffer++;
+    if (m.isSkinnedMesh) g.skinned++;
+    if (mats.some((x) => x && x.map && x.map.isTexture)) g.textured++;
+    g.tris += tris;
+    g.share = Math.min(1, g.share + share);
+  };
+  const walk = (o, topName, hero, on) => {
+    const shown = on && o.visible !== false;
+    const name = o.name || '';
+    const owner = hero || (name && HERO.test(name) ? name : null); // the outermost hero node owns its parts
+    if ((o.isMesh || o.isInstancedMesh) && shown) {
+      const share = shareOf(o);
+      if (share > 0 || !cam) {
+        add(totals, o, share);
+        if (!top.has(topName)) top.set(topName, empty(topName));
+        add(top.get(topName), o, share);
+        if (owner) { if (!heroes.has(owner)) heroes.set(owner, empty(owner)); add(heroes.get(owner), o, share); }
+      }
+    }
+    for (const c of o.children || []) walk(c, topName, owner, shown);
+  };
+  for (const c of scene.children || []) walk(c, c.name || c.type || '(unnamed)', null, true);
+  const round = (g) => ({ ...g, share: Math.round(g.share * 1000) / 1000 });
+  const bySize = (m) => [...m.values()].sort((x, y) => y.share - x.share || y.meshes - x.meshes).slice(0, MAX).map(round);
+  out.heroes = bySize(heroes);
+  out.top = bySize(top);
+  out.totals = round(totals);
+  return JSON.stringify(out);
+}