@funpixel/tools 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,25 @@
+// Run the game's own window.__FPX_SELFTEST__ array. A failed test gates like an
+// unreachable mechanic.
+// a = { max, timeout_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 t = window.__FPX_SELFTEST__;
+  if (!Array.isArray(t)) return 'none';
+  const out = [];
+  for (const x of t.slice(0, a.max)) {
+    const name = (x && typeof x.name === 'string' && x.name.trim()) ? x.name.trim() : ('test ' + (out.length + 1));
+    if (!x || typeof x.run !== 'function') { out.push({ name, pass: false, error: 'no run() function' }); continue; }
+    try {
+      const timeout = new Promise((_, rej) => setTimeout(() => rej(new Error('timed out after a.timeout_ms ms')), a.timeout_ms));
+      const v = await Promise.race([Promise.resolve().then(() => x.run()), timeout]);
+      out.push({ name, pass: !!v, error: v ? '' : ('returned ' + JSON.stringify(v)) });
+    } catch (e) {
+      out.push({ name, pass: false, error: 'threw: ' + (e && e.message ? e.message : String(e)) });
+    }
+  }
+  return JSON.stringify({ declared: true, results: out });
+}
+

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

@@ -0,0 +1,247 @@
+// The held clock (8 Oct): the page's time stands still until the caller moves
+// it, in fixed frames from a known seed, so two captures of one view show the
+// same pixels and a round's before and after are the same frame (KIT_PLAN,
+// "From Genex's own page": blind A/B judging needs it).
+//
+// Installed BEFORE the game's code, as an init script (local `funtools
+// capture`, `score --target`, `compare --target`; the hosted looks do not
+// install it and stay free-running). It holds:
+//   requestAnimationFrame   a frame runs only inside advance(), one every frame_ms
+//   setTimeout/setInterval  due on the held clock, fired in order inside advance()
+//   performance.now()       the held time; Date.now() the same from a fixed day
+//                           (1 Jan 2026 UTC)
+//   Math.random             seeded from the seed (mulberry32), so effects drawn
+//                           with it repeat
+//   CSS / Web Animations    each paused and set to its own age on the held clock
+//                           after every frame
+//   window.__FPX_SEED__     the seed, unless the page set one; reads are counted,
+//                           so a capture can say whether the game followed it
+// Work the wall clock decides is waited out before every step, so it lands on
+// the same frame every time: no held time passes while the page awaits a
+// fetch or its body, createImageBitmap, an image's decode(), a font's load(),
+// a GPU adapter, or a Worker's answer to a message (a texture or a mesh
+// decoded off the main thread; a worker that never answers is given 1 s), nor (when the caller gives window.__FPX_NET_QUIET__, an async
+// function that resolves once nothing is in flight; funtools exposes it from
+// Playwright's request events) while any request is out — a lazy chunk, a
+// model, a font. WebGL's KHR_parallel_shader_compile is hidden, so an engine
+// that polls for compiled shaders (three's compileAsync) finds them ready on
+// its first look instead of after a wall-clock wait.
+// Not held: AudioContext time, Web Workers (a Draco decode), `new Date()`,
+// requestIdleCallback, video and GIF frames.
+//
+// The page scripts that wait (capture_view.js, front_door.js, life.js) wait on
+// window.__FPX_STEP_CLOCK__.sleep when it is there, so their waits are game
+// time too and nothing hangs on a timer the held clock never fires.
+//
+// Part of @funpixel/verify: one function expression of one argument. Unlike
+// the others it is run as an init script: (pageScript('step_clock', a))().
+//
+// a = { seed?: whole number (1), frame_ms?: number (1000 / 60) }
+// window.__FPX_STEP_CLOCK__ = { held: true, frame_ms, advance(ms, stop?),
+//   sleep(ms), within(promise, ms), now(), report(), real }
+//   advance  runs the timers and frames due within ms, in order, letting the
+//            page's own tasks run between them; stop() (checked between steps)
+//            ends it early. Answers the held ms moved
+//   report() { held, frame_ms, seed, seed_reads, at_ms, frames, game_frames,
+//            timers, pending_timers, errors }: game_frames counts the game's
+//            frame callbacks run (0 = its loop runs on something not held)
+// Answers 'installed', or 'already' when the page has one.
+(a) => {
+  const w = window;
+  if (w.__FPX_STEP_CLOCK__) return 'already';
+  const FRAME = Number(a && a.frame_ms) > 0 ? Number(a.frame_ms) : 1000 / 60;
+  const EPOCH = 1767225600000;
+  const real = {
+    setTimeout: w.setTimeout.bind(w), clearTimeout: w.clearTimeout.bind(w),
+    requestAnimationFrame: w.requestAnimationFrame.bind(w), now: performance.now.bind(performance),
+  };
+  let now = 0, frame = 0, nextId = 1, seq = 0, gameFrames = 0, timersRun = 0, inTimer = false;
+  const errors = [];
+  const rafs = new Map();
+  const timers = new Map();
+
+  let seed = Number.isInteger(a && a.seed) ? a.seed : 1, reads = 0;
+  if (typeof w.__FPX_SEED__ === 'number') seed = w.__FPX_SEED__;
+  try {
+    Object.defineProperty(w, '__FPX_SEED__', { configurable: true, enumerable: true, get() { reads++; return seed; }, set(v) { seed = v; } });
+  } catch (e) { w.__FPX_SEED__ = seed; }
+  let r = (seed ^ 0x9e3779b9) >>> 0;
+  Math.random = () => {
+    r = (r + 0x6d2b79f5) >>> 0;
+    let t = r;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+
+  // The page's own waits on the outside world, settled before each step (at most 5 s each).
+  const pending = new Set();
+  const track = (p) => {
+    if (p && typeof p.then === 'function') { pending.add(p); const drop = () => pending.delete(p); p.then(drop, drop); }
+    return p;
+  };
+  const wrap = (owner, name) => {
+    const f = owner && owner[name];
+    if (typeof f !== 'function') return;
+    owner[name] = function (...args) { return track(f.apply(this, args)); };
+  };
+  wrap(w, 'fetch');
+  if (w.Response) for (const n of ['arrayBuffer', 'blob', 'json', 'text', 'formData']) wrap(w.Response.prototype, n);
+  wrap(w, 'createImageBitmap');
+  try { if (w.navigator && w.navigator.gpu) wrap(w.navigator.gpu, 'requestAdapter'); } catch (e) { /* no WebGPU */ }
+  if (w.Worker) {
+    const post = w.Worker.prototype.postMessage;
+    w.Worker.prototype.postMessage = function (...args) {
+      const worker = this;
+      track(new Promise((res) => {
+        const cap = real.setTimeout(done, 1000);
+        function done() { real.clearTimeout(cap); worker.removeEventListener('message', done); worker.removeEventListener('error', done); res(); }
+        worker.addEventListener('message', done);
+        worker.addEventListener('error', done);
+      }));
+      return post.apply(this, args);
+    };
+  }
+  if (w.HTMLImageElement) wrap(w.HTMLImageElement.prototype, 'decode');
+  if (w.FontFace) wrap(w.FontFace.prototype, 'load');
+  try { if (document.fonts) wrap(document.fonts, 'load'); } catch (e) { /* no font loading API */ }
+  for (const C of [w.WebGLRenderingContext, w.WebGL2RenderingContext]) {
+    if (!C) continue;
+    const ext = C.prototype.getExtension, list = C.prototype.getSupportedExtensions;
+    C.prototype.getExtension = function (n) { return /parallel_shader_compile/i.test(String(n)) ? null : ext.call(this, n); };
+    C.prototype.getSupportedExtensions = function () { const l = list.call(this); return Array.isArray(l) ? l.filter((n) => !/parallel_shader_compile/i.test(n)) : l; };
+  }
+
+  performance.now = () => now;
+  Date.now = () => Math.round(EPOCH + now);
+  w.requestAnimationFrame = (cb) => { const id = nextId++; if (typeof cb === 'function') rafs.set(id, cb); return id; };
+  w.cancelAnimationFrame = (id) => { rafs.delete(id); };
+  // A zero delay set from inside a timer still moves the clock (a browser clamps it too), so a
+  // timer that sets itself again cannot spin advance() in place.
+  const delay = (ms) => Math.max(inTimer ? 1 : 0, Number(ms) || 0);
+  w.setTimeout = (fn, ms, ...args) => {
+    if (typeof fn !== 'function') return real.setTimeout(fn, ms, ...args);
+    const id = nextId++;
+    timers.set(id, { due: now + delay(ms), seq: seq++, fn, args, every: 0 });
+    return id;
+  };
+  w.setInterval = (fn, ms, ...args) => {
+    if (typeof fn !== 'function') return 0;
+    const id = nextId++, every = Math.max(1, Number(ms) || 0);
+    timers.set(id, { due: now + every, seq: seq++, fn, args, every });
+    return id;
+  };
+  w.clearTimeout = w.clearInterval = (id) => { if (!timers.delete(id)) real.clearTimeout(id); };
+
+  // Between steps the page's own tasks run (a React commit, a decoded image, a resolved fetch);
+  // a MessageChannel turn, not a timer, so no browser clamp slows a long advance.
+  const ch = new MessageChannel(), turns = [];
+  ch.port1.onmessage = () => { const f = turns.shift(); if (f) f(); };
+  const task = () => new Promise((res) => { turns.push(res); ch.port2.postMessage(0); });
+  // A ResizeObserver answers only in the browser's own rendering step. So when an element one observes
+  // changed size, the step waits for a real frame: the resize is reported before the next frame runs, on
+  // every take (the SDK's setupGameResize observes the stage), and a step that resized nothing stays fast.
+  const watched = new Set(), sizes = new WeakMap();
+  if (typeof w.ResizeObserver === 'function') {
+    const RO = w.ResizeObserver;
+    w.ResizeObserver = class extends RO { observe(el, ...rest) { if (el) watched.add(el); return super.observe(el, ...rest); } };
+  }
+  const resized = () => {
+    let any = false;
+    for (const el of watched) {
+      let k = '';
+      try { const r = el.getBoundingClientRect(); k = `${r.width}x${r.height}`; } catch (e) { continue; }
+      if (sizes.get(el) !== k) { sizes.set(el, k); any = true; }
+    }
+    return any;
+  };
+  const paint = () => new Promise((res) => {
+    const cap = real.setTimeout(res, 50);
+    real.requestAnimationFrame(() => real.requestAnimationFrame(() => { real.clearTimeout(cap); res(); }));
+  });
+  const turn = async () => { await task(); if (watched.size && resized()) { await paint(); await task(); } };
+  const run = (fn, args) => {
+    try { fn(...args); } catch (e) {
+      if (errors.length < 8) errors.push(String((e && e.message) || e).slice(0, 200));
+      real.setTimeout(() => { throw e; }, 0);
+    }
+  };
+  const born = new WeakMap();
+  const settle = () => {
+    let list = [];
+    try { list = document.getAnimations(); } catch (e) { return; }
+    for (const an of list) {
+      if (!born.has(an)) { if (an.playState === 'paused') continue; born.set(an, now); }
+      try { an.pause(); an.currentTime = now - born.get(an); } catch (e) { /* a finished or removed one */ }
+    }
+  };
+  const nextTimer = () => {
+    let best = null;
+    for (const entry of timers) if (!best || entry[1].due < best[1].due || (entry[1].due === best[1].due && entry[1].seq < best[1].seq)) best = entry;
+    return best;
+  };
+  const present = () => new Promise((res) => {
+    const done = real.setTimeout(res, 100);
+    real.requestAnimationFrame(() => real.requestAnimationFrame(() => { real.clearTimeout(done); res(); }));
+  });
+
+  const quiet = async () => {
+    for (let i = 0; i < 4 && pending.size; i++) {
+      await new Promise((res) => { const cap = real.setTimeout(res, 5000); Promise.allSettled([...pending]).then(() => { real.clearTimeout(cap); res(); }); });
+      await turn();
+    }
+    if (typeof w.__FPX_NET_QUIET__ === 'function') { try { await w.__FPX_NET_QUIET__(); } catch (e) { /* the caller went away */ } }
+  };
+  async function advance(ms, stop) {
+    const from = now, target = now + Math.max(0, Number(ms) || 0);
+    await turn();
+    await quiet();
+    let stopped = !!(stop && stop());
+    for (let steps = 0; !stopped && steps < 200000; steps++) {
+      const at = (frame + 1) * FRAME;
+      const t = nextTimer();
+      if (t && t[1].due <= Math.min(at, target)) {
+        const [id, tm] = t;
+        now = Math.max(now, tm.due);
+        if (tm.every) tm.due = now + tm.every; else timers.delete(id);
+        timersRun++;
+        inTimer = true;
+        run(tm.fn, tm.args);
+        inTimer = false;
+      } else if (at <= target + 1e-9) {
+        now = at; frame++;
+        const due = [...rafs.values()];
+        rafs.clear();
+        for (const cb of due) { gameFrames++; run(cb, [now]); }
+        settle();
+      } else break;
+      await turn();
+      await quiet();
+      stopped = !!(stop && stop());
+    }
+    if (!stopped) now = target;
+    await present();
+    return now - from;
+  }
+
+  w.__FPX_STEP_CLOCK__ = {
+    held: true,
+    frame_ms: FRAME,
+    real,
+    advance,
+    sleep: (ms) => advance(ms),
+    within: async (p, ms) => {
+      const q = Promise.resolve(p);
+      let done = false;
+      q.then(() => { done = true; }, () => { done = true; });
+      await advance(ms, () => done);
+      return done ? q : undefined;
+    },
+    now: () => now,
+    report: () => ({
+      held: true, frame_ms: Math.round(FRAME * 1000) / 1000, seed, seed_reads: reads, at_ms: Math.round(now * 10) / 10,
+      frames: frame, game_frames: gameFrames, timers: timersRun, pending_timers: timers.size, errors: errors.slice(),
+    }),
+  };
+  return 'installed';
+}

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

@@ -0,0 +1,261 @@
+// What each part of the frame is made of (owner, 2 Oct, one game's round 4: "the environment
+// still has boxes, must be fixed" — flat-colour containers beside one painted building, big
+// flat-shaded slabs filling the foreground). A coarse software raster of the Three scene from the
+// play camera: every cell of a grid over the canvas gets the NEAREST triangle under its centre, so
+// what is hidden behind something else never counts. Per mesh it answers how much of the frame it
+// covers, how big its triangles are on screen (a 12-triangle box filling a quarter of the frame has
+// few vertices for its size), how near it is and what its material carries (a texture map, a custom
+// shader, vertex colours, flat shading). The pixels are read by the caller (funtools boxes and walk:
+// a screenshot taken beside this reading), which decides what reads flat. Read-only.
+//
+// Skipped: sprites, points and lines; skinned meshes (their bind pose is not where they are drawn);
+// see-through glows and veils (transparent and not writing depth). A mesh that wraps the camera (a
+// sky dome, a panorama riding with it) or is named like a sky or backdrop is a backdrop: its cells
+// count as background.
+//
+// Part of @funpixel/verify: one function expression of one argument. See mechanic_check.js for the
+// calling convention.
+//
+// a = { cells (grid cells across the canvas, default 96; rows follow the aspect), big (a triangle
+//       whose projected area is at least this share of the frame is big, default 0.004),
+//       max_tris (cap on triangles rastered, default 600000), backdrop (regex source for backdrop
+//       names) }
+//
+// Answers JSON:
+//   engine  — three | none;  error — why nothing was read
+//   view    — { left, top, width, height } of the canvas in CSS px
+//   grid    — { cols, rows }
+//   cells   — per cell (row-major) the mesh index, -1 = background
+//   tri     — per cell the share of the frame its triangle covers on screen (0..1, 4 places)
+//   depth   — per cell the distance from the camera in world units (1 place), 0 = background
+//   meshes  — [{ name, path, kind: mesh|instanced, instances, verts, tris, cells, big_cells,
+//               max_tri, near, backdrop, material: { type, name, map, custom, vertex_colors, flat,
+//               color, textures } }]
+//   tris_read, capped
+//   figures — the people and creatures of the actors contract (kind person|creature, by their `node`) built as a
+//             handful of boxes, whatever their size on screen (lane J4, one game's r5: a herder and the hound were four
+//             and seven flat boxes, too small on screen for the area read): [{ id, kind, node, meshes, boxes (how many
+//             are cuboids: a BoxGeometry, or eight corners and axis-aligned faces), verts, on (in front of the camera) }]
+(a) => {
+  const out = { engine: 'none', error: '', view: null, grid: null, cells: [], tri: [], depth: [], meshes: [], tris_read: 0, capped: false, figures: [] };
+  const scene = window.__THREEJS_SCENE__ || (window.scene && window.scene.isScene ? window.scene : null);
+  if (!scene || !scene.isObject3D) { out.error = 'no Three scene (window.__THREEJS_SCENE__)'; return JSON.stringify(out); }
+  out.engine = 'three';
+  let cam = window.camera || window.__THREEJS_CAMERA__ || null;
+  if (!cam || !cam.isCamera) { scene.traverse && scene.traverse((o) => { if (!cam && o.isCamera) cam = o; }); }
+  if (!cam || !cam.isCamera) { out.error = 'no camera (window.camera or window.__THREEJS_CAMERA__)'; return JSON.stringify(out); }
+  const ren = window.__THREEJS_RENDERER__ || window.renderer;
+  const canvas = (ren && ren.domElement) || (typeof document !== 'undefined' && document.querySelector ? document.querySelector('canvas') : null);
+  const rect = canvas && canvas.getBoundingClientRect ? canvas.getBoundingClientRect() : { left: 0, top: 0, width: 1280, height: 720 };
+  out.view = { left: Math.round(rect.left), top: Math.round(rect.top), width: Math.round(rect.width), height: Math.round(rect.height) };
+  const COLS = Math.max(8, Math.min(240, a.cells || 96));
+  const ROWS = Math.max(4, Math.round((COLS * (rect.height || 720)) / (rect.width || 1280)));
+  out.grid = { cols: COLS, rows: ROWS };
+  const BIG = typeof a.big === 'number' ? a.big : 0.004;
+  const MAX_TRIS = a.max_tris || 600000;
+  const BACKDROP = new RegExp(a.backdrop || 'sky|backdrop|panorama|background|horizon|cloud|stars|skybox|dome', 'i');
+
+  scene.updateMatrixWorld && scene.updateMatrixWorld();
+  cam.updateMatrixWorld && cam.updateMatrixWorld();
+  if (cam.matrixWorldInverse && cam.matrixWorldInverse.copy && cam.matrixWorld) cam.matrixWorldInverse.copy(cam.matrixWorld).invert();
+  // Column-major 4x4 products, as Three stores them.
+  const mul = (A, B) => {
+    const o = new Array(16);
+    for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) o[c * 4 + r] = A[r] * B[c * 4] + A[4 + r] * B[c * 4 + 1] + A[8 + r] * B[c * 4 + 2] + A[12 + r] * B[c * 4 + 3];
+    return o;
+  };
+  const VP = mul(cam.projectionMatrix.elements, cam.matrixWorldInverse.elements);
+  const camPos = { x: cam.matrixWorld.elements[12], y: cam.matrixWorld.elements[13], z: cam.matrixWorld.elements[14] };
+
+  const N = COLS * ROWS;
+  const cellMesh = new Int32Array(N).fill(-1), cellTri = new Float32Array(N), cellDepth = new Float32Array(N).fill(Infinity);
+  const meshes = [];
+  const pathOf = (o) => { const p = []; for (let n = o; n && !n.isScene && p.length < 4; n = n.parent) if (n.name) p.unshift(n.name); return p.join('/'); };
+  const texturesOf = (m) => {
+    let n = 0;
+    for (const k of ['map', 'normalMap', 'bumpMap', 'emissiveMap', 'aoMap', 'roughnessMap', 'matcap', 'alphaMap', 'gradientMap']) if (m[k] && m[k].isTexture) n++;
+    if (m.uniforms) for (const u of Object.values(m.uniforms)) if (u && u.value && u.value.isTexture) n++;
+    return n;
+  };
+  const matOf = (m) => ({
+    type: String(m.type || ''), name: String(m.name || ''), map: !!(m.map && m.map.isTexture),
+    custom: !!(m.onBeforeCompile && String(m.onBeforeCompile).length > 30) || !!m.isShaderMaterial || !!m.isRawShaderMaterial,
+    vertex_colors: !!m.vertexColors, flat: !!m.flatShading, color: m.color && m.color.getHexString ? `#${m.color.getHexString()}` : null, textures: texturesOf(m),
+  });
+  const seeThrough = (m) => !m || m.visible === false || m.colorWrite === false || (m.transparent && (m.depthWrite === false || (typeof m.opacity === 'number' && m.opacity < 0.5)));
+
+  // Clip a polygon of clip-space points against the near plane (z > -w), then raster it.
+  const clipNear = (poly) => {
+    const res = [];
+    for (let i = 0; i < poly.length; i++) {
+      const p = poly[i], q = poly[(i + 1) % poly.length];
+      const dp = p[2] + p[3], dq = q[2] + q[3];
+      if (dp >= 0) res.push(p);
+      if ((dp >= 0) !== (dq >= 0)) { const t = dp / (dp - dq); res.push([p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t, p[2] + (q[2] - p[2]) * t, p[3] + (q[3] - p[3]) * t]); }
+    }
+    return res;
+  };
+  const sx = (p) => ((p[0] / p[3] + 1) / 2) * COLS, sy = (p) => ((1 - p[1] / p[3]) / 2) * ROWS;
+  let tris = 0;
+  const won = [];
+  // cull: 1 = draw front faces only, -1 = back faces only, 0 = both; far: a backdrop, behind everything.
+  let cull = 1, far = 0;
+  const raster = (mi, A, B, C) => {
+    // Screen space; 1/w interpolates linearly.
+    const ax = sx(A), ay = sy(A), bx = sx(B), by = sy(B), cx = sx(C), cy = sy(C);
+    const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+    if (!Number.isFinite(area) || Math.abs(area) < 1e-9) return 0;
+    // Front faces wind counter-clockwise in NDC, so clockwise on a y-down grid: a negative area.
+    if ((cull > 0 && area > 0) || (cull < 0 && area < 0)) return 0;
+    const x0 = Math.max(0, Math.floor(Math.min(ax, bx, cx))), x1 = Math.min(COLS - 1, Math.ceil(Math.max(ax, bx, cx)));
+    const y0 = Math.max(0, Math.floor(Math.min(ay, by, cy))), y1 = Math.min(ROWS - 1, Math.ceil(Math.max(ay, by, cy)));
+    if (x0 > x1 || y0 > y1) return Math.abs(area) / 2;
+    const iwA = 1 / A[3], iwB = 1 / B[3], iwC = 1 / C[3];
+    for (let y = y0; y <= y1; y++) {
+      const py = y + 0.5;
+      for (let x = x0; x <= x1; x++) {
+        const px = x + 0.5;
+        const w0 = ((bx - px) * (cy - py) - (by - py) * (cx - px)) / area;
+        const w1 = ((cx - px) * (ay - py) - (cy - py) * (ax - px)) / area;
+        const w2 = 1 - w0 - w1;
+        if (w0 < 0 || w1 < 0 || w2 < 0) continue;
+        const d = 1 / (w0 * iwA + w1 * iwB + w2 * iwC) + far;
+        const k = y * COLS + x;
+        if (d < cellDepth[k]) { cellDepth[k] = d; cellMesh[k] = mi; won.push(k); }
+      }
+    }
+    return Math.abs(area) / 2;
+  };
+
+  const visibleChain = (o) => { for (let n = o; n; n = n.parent) if (n.visible === false) return false; return true; };
+  const all = [];
+  scene.traverse && scene.traverse((o) => { if ((o.isMesh || o.isInstancedMesh) && !o.isSkinnedMesh && !o.isSprite && o.geometry && visibleChain(o)) all.push(o); });
+  for (const o of all) {
+    if (out.capped) break;
+    const g = o.geometry, pos = g.attributes && g.attributes.position;
+    if (!pos || !pos.count) continue;
+    const mats = Array.isArray(o.material) ? o.material : [o.material];
+    if (mats.every(seeThrough)) continue;
+    const inst = o.isInstancedMesh ? Math.max(0, o.count | 0) : 1;
+    if (!inst) continue;
+    const idx = g.index ? g.index.array : null;
+    const triCount = Math.floor((idx ? idx.length : pos.count) / 3);
+    // A backdrop: named so, or its box wraps the camera (a dome or a ring riding with it).
+    if (!g.boundingBox && g.computeBoundingBox) g.computeBoundingBox();
+    let wraps = false;
+    if (g.boundingBox && !o.isInstancedMesh) {
+      const e = o.matrixWorld.elements, bb = g.boundingBox;
+      const cx = (bb.min.x + bb.max.x) / 2, cy = (bb.min.y + bb.max.y) / 2, cz = (bb.min.z + bb.max.z) / 2;
+      const wx = e[0] * cx + e[4] * cy + e[8] * cz + e[12], wy = e[1] * cx + e[5] * cy + e[9] * cz + e[13], wz = e[2] * cx + e[6] * cy + e[10] * cz + e[14];
+      const s = Math.hypot(e[0], e[1], e[2]);
+      const half = Math.max(bb.max.x - bb.min.x, bb.max.y - bb.min.y, bb.max.z - bb.min.z) * s / 2;
+      const span = Math.min(bb.max.x - bb.min.x, bb.max.z - bb.min.z) * s / 2;
+      wraps = Math.abs(wx - camPos.x) < span * 0.9 && Math.abs(wz - camPos.z) < span * 0.9 && Math.abs(wy - camPos.y) < half && span > 50 && (mats[0].side === 1 || mats[0].side === 2 || mats[0].depthWrite === false || mats[0].fog === false);
+    }
+    const name = o.name || (o.parent && o.parent.name) || o.type;
+    const mi = meshes.length;
+    const m0 = mats.find((m) => !seeThrough(m)) || mats[0];
+    meshes.push({ name, path: pathOf(o), kind: o.isInstancedMesh ? 'instanced' : 'mesh', instances: inst, verts: pos.count, tris: triCount, cells: 0, big_cells: 0, max_tri: 0, near: null, backdrop: wraps || BACKDROP.test(name) || BACKDROP.test(pathOf(o)), material: matOf(m0) });
+    const groups = Array.isArray(o.material) && g.groups && g.groups.length ? g.groups : null;
+    // Positions as floats: through getX/Y/Z, so quantized (normalized) and interleaved attributes read right.
+    let arr = pos.array;
+    if (pos.normalized || pos.isInterleavedBufferAttribute || !(arr instanceof Float32Array) || pos.itemSize !== 3) {
+      arr = new Float32Array(pos.count * 3);
+      for (let v = 0; v < pos.count; v++) { arr[v * 3] = pos.getX(v); arr[v * 3 + 1] = pos.getY(v); arr[v * 3 + 2] = pos.getZ(v); }
+    }
+    const W = o.matrixWorld.elements;
+    for (let i = 0; i < inst; i++) {
+      let M = W;
+      if (o.isInstancedMesh) { const ia = o.instanceMatrix.array; M = mul(W, Array.prototype.slice.call(ia, i * 16, i * 16 + 16)); }
+      const P = mul(VP, M);
+      // A mirrored transform turns the winding over.
+      const det = M[0] * (M[5] * M[10] - M[6] * M[9]) - M[4] * (M[1] * M[10] - M[2] * M[9]) + M[8] * (M[1] * M[6] - M[2] * M[5]);
+      const side = m0.side === 2 ? 0 : m0.side === 1 ? -1 : 1;
+      cull = det < 0 ? -side : side;
+      far = meshes[mi].backdrop ? 1e7 : 0;
+      const clip = (vi) => {
+        const b = vi * 3, x = arr[b], y = arr[b + 1], z = arr[b + 2];
+        return [P[0] * x + P[4] * y + P[8] * z + P[12], P[1] * x + P[5] * y + P[9] * z + P[13], P[2] * x + P[6] * y + P[10] * z + P[14], P[3] * x + P[7] * y + P[11] * z + P[15]];
+      };
+      for (let t = 0; t < triCount; t++) {
+        if (groups) { const gr = groups.find((q) => t * 3 >= q.start && t * 3 < q.start + q.count); if (gr && seeThrough(o.material[gr.materialIndex])) continue; }
+        if (++tris > MAX_TRIS) { out.capped = true; break; }
+        const i0 = idx ? idx[t * 3] : t * 3, i1 = idx ? idx[t * 3 + 1] : t * 3 + 1, i2 = idx ? idx[t * 3 + 2] : t * 3 + 2;
+        const pa = clip(i0), pb = clip(i1), pc = clip(i2);
+        // Outside one frustum side entirely: skip early.
+        if ((pa[0] > pa[3] && pb[0] > pb[3] && pc[0] > pc[3]) || (pa[0] < -pa[3] && pb[0] < -pb[3] && pc[0] < -pc[3])) continue;
+        if ((pa[1] > pa[3] && pb[1] > pb[3] && pc[1] > pc[3]) || (pa[1] < -pa[3] && pb[1] < -pb[3] && pc[1] < -pc[3])) continue;
+        let poly = [pa, pb, pc];
+        if (pa[2] + pa[3] < 0 || pb[2] + pb[3] < 0 || pc[2] + pc[3] < 0) poly = clipNear(poly);
+        if (poly.length < 3) continue;
+        // The polygon's whole projected area (its share of the frame), then each fan triangle rastered.
+        let area = 0;
+        for (let k = 1; k + 1 < poly.length; k++) area += raster(mi, poly[0], poly[k], poly[k + 1]);
+        // The cells this polygon just won carry its whole share of the frame.
+        for (const k of won) cellTri[k] = area / N;
+        won.length = 0;
+      }
+    }
+  }
+  out.tris_read = tris;
+  const r1 = (v) => Math.round(v * 10) / 10;
+  for (let k = 0; k < N; k++) {
+    const mi = cellMesh[k];
+    out.cells.push(mi);
+    out.tri.push(mi < 0 ? 0 : Math.round(cellTri[k] * 10000) / 10000);
+    const dk = mi < 0 ? 0 : r1(cellDepth[k] - (meshes[mi].backdrop ? 1e7 : 0));
+    out.depth.push(dk);
+    if (mi < 0) continue;
+    const m = meshes[mi];
+    m.cells++;
+    if (cellTri[k] >= BIG) m.big_cells++;
+    m.max_tri = Math.max(m.max_tri, Math.round(cellTri[k] * 10000) / 10000);
+    m.near = m.near === null ? dk : Math.min(m.near, dk);
+  }
+  out.meshes = meshes;
+
+  // ---- box figures: the contract's people and creatures, as built --------------------------------------
+  try {
+    const f = window.__FPX_ACTORS__;
+    const got = typeof f === 'function' ? f() : f;
+    const list = got && Array.isArray(got.actors) ? got.actors : Array.isArray(got) ? got : [];
+    const living = list.filter((x) => x && typeof x.node === 'string' && x.node && /player|person|people|folk|npc|human|child|kid|creature|animal|beast|hound|dog|cat|fox|bird|crab/i.test(String(x.kind || '')) && !/player/i.test(String(x.kind || ''))).slice(0, 80);
+    if (living.length) {
+      const byName = new Map();
+      scene.traverse((o) => { if (o.name) { const l = byName.get(o.name) || []; l.push(o); byName.set(o.name, l); } });
+      // A cuboid: a BoxGeometry, or a mesh of at most 36 vertices on exactly two values per local axis (eight corners).
+      const cuboid = (g) => {
+        if (g.type === 'BoxGeometry' || g.type === 'BoxBufferGeometry') return true;
+        const pos = g.attributes && g.attributes.position;
+        if (!pos || pos.count > 36) return false;
+        const ax = [new Set(), new Set(), new Set()];
+        for (let i = 0; i < pos.count; i++) { ax[0].add(Math.round(pos.getX(i) * 1e4)); ax[1].add(Math.round(pos.getY(i) * 1e4)); ax[2].add(Math.round(pos.getZ(i) * 1e4)); }
+        return ax.every((s) => s.size === 2); // a flat card (one value on an axis) is a picture, not a box
+      };
+      const seen = new Set();
+      for (const x of living) {
+        const l = byName.get(x.node); if (!l) continue;
+        const px = typeof x.x === 'number' ? x.x : 0, pz = typeof x.z === 'number' ? x.z : 0;
+        let root = null, bd = Infinity;
+        for (const o of l) { const e = o.matrixWorld.elements, d = Math.hypot(e[12] - px, e[14] - pz); if (d < bd) { bd = d; root = o; } }
+        if (!root || seen.has(root) || !visibleChain(root)) continue;
+        seen.add(root);
+        let n = 0, boxes = 0, verts = 0, skinned = false;
+        root.traverse((o) => {
+          if (o.isSkinnedMesh) skinned = true;
+          if (!(o.isMesh || o.isInstancedMesh) || o.isSprite || !o.geometry || o.visible === false) return;
+          const m = Array.isArray(o.material) ? o.material[0] : o.material;
+          if (seeThrough(m) || (m && m.side === 1)) return; // a glow, an outline shell
+          n++; verts += (o.geometry.attributes && o.geometry.attributes.position ? o.geometry.attributes.position.count : 0) * (o.isInstancedMesh ? o.count : 1);
+          if (cuboid(o.geometry)) boxes += o.isInstancedMesh ? o.count : 1;
+        });
+        if (!n || skinned) continue;
+        const e = root.matrixWorld.elements;
+        const cw = VP[3] * e[12] + VP[7] * e[13] + VP[11] * e[14] + VP[15];
+        const on = cw > 0 && Math.abs((VP[0] * e[12] + VP[4] * e[13] + VP[8] * e[14] + VP[12]) / cw) <= 1.1 && Math.abs((VP[1] * e[12] + VP[5] * e[13] + VP[9] * e[14] + VP[13]) / cw) <= 1.1;
+        out.figures.push({ id: String(x.id || x.node), kind: String(x.kind || ''), node: x.node, meshes: n, boxes, verts, on });
+      }
+    }
+  } catch (e) { /* no contract */ }
+  return JSON.stringify(out);
+}