@funpixel/tools 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,264 @@
+// Where every actor of the world stands, how big it is and where it lands on screen (owner, 1 Oct,
+// one game: "lots of misplaces, collisions"; "we don't play and verify the environment is right
+// and well built"). Read by `funtools walk` each tick (clipping, floating, scale, blocked paths) and
+// by `funtools framing` (each actor's box on screen and its height share, so a camera can be set to
+// a target's framing without rebuild-and-shoot rounds). Read-only.
+//
+// THE STATE CONTRACT (HOOKS.md, "Actors"): the game answers `window.__FPX_ACTORS__()` (or an
+// `actors` ARRAY in `__FPX_STATE__()`) with one entry per actor, in metres, y up:
+//   { id, kind: player|person|creature|machine|prop, type?, x, y, z (the FEET: bottom centre),
+//     h (height), w?, d? (footprint box) or r (footprint radius), ground? (terrain height under the
+//     feet), grounded?, flies?, solid? (default true), state?, node? (the scene node's name) }
+// Without it, a Three scene is read instead: named nodes matching the kind words below, boxed from
+// their meshes and sprites as posed now; ground is then not observed.
+// More shapes are read as the same contract (one game's round 3, the owner's build answered a bare
+// array with the species in `kind` and no `type`): a bare array or an { id: actor } map; a species or
+// role word in `kind` (crab, townsfolk, npc, drone) read into person | creature | machine with the
+// word kept as `type`; no `type` = `species` | `role` | the id without its number; `flying` = `flies`;
+// the feet as `pos`/`position` ({x,y,z} or [x,y,z]). A person's `scene` (or `group`) names the little scene
+// it belongs to (people of one scene may stand close); `landed: true` marks a vehicle or prop that must
+// rest on the ground. The full contract ships with the kit:
+// skill funpixel-verify, references/actors.md.
+//
+// Part of @funpixel/verify: one function expression of one argument. See mechanic_check.js for the
+// calling convention.
+//
+// a = { ids: [] (only these ids or node names; empty = all), player, people, creatures, machines,
+//       props: regex sources (scene fallback only); max (200) }
+//
+// Answers JSON:
+//   source  — contract | scene | none;  engine — three | pixi | none
+//   unit    — the contract's unit (default m)
+//   actors  — [{ id, kind, type, x, y, z, w, h, d, r, ground, grounded, flies, solid, state, node, facing (people and
+//                creatures: the world yaw of their forward, from the contract's facing/heading or the node),
+//                screen: { x, y, w, h, share, on } | null }]  (screen: CSS px of the page; share =
+//                the box's height over the canvas height; on = any of it in view, in front)
+//   view    — { width, height } of the canvas in CSS px, or null
+//   error   — why the contract could not be read (it threw, or answered no list)
+async (a) => {
+  const MAX = a.max || 200;
+  const ids = Array.isArray(a.ids) ? a.ids.map(String) : [];
+  const want = (x) => !ids.length || ids.includes(String(x.id)) || (x.node && ids.includes(String(x.node)));
+  const out = { source: 'none', engine: 'none', unit: 'm', actors: [], view: null, error: '' };
+  const KINDS = ['player', 'person', 'creature', 'machine', 'prop'];
+  const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+
+  // --- the contract ----------------------------------------------------------
+  let list = null;
+  // An { id: actor } map counts when its values look like actors (a position each), not a map of states.
+  const fromMap = (m) => {
+    if (!m || typeof m !== 'object' || Array.isArray(m)) return null;
+    const rows = Object.entries(m).filter(([, v]) => v && typeof v === 'object' && (typeof v.x === 'number' || v.pos || v.position));
+    return rows.length ? rows.map(([k, v]) => ({ id: k, ...v })) : null;
+  };
+  try {
+    const fn = window.__FPX_ACTORS__;
+    const got = typeof fn === 'function' ? fn() : fn;
+    if (got && Array.isArray(got.actors)) { list = got.actors; if (typeof got.unit === 'string') out.unit = got.unit; }
+    else if (Array.isArray(got)) list = got;
+    else if (got && typeof got === 'object') list = fromMap(got.actors) || fromMap(got);
+    if (!list && typeof window.__FPX_STATE__ === 'function') {
+      const s = window.__FPX_STATE__();
+      if (s && Array.isArray(s.actors)) list = s.actors;
+      else if (s) list = fromMap(s.actors);
+    }
+  } catch (e) { out.error = `the actors contract threw: ${String((e && e.message) || e).slice(0, 160)}`; }
+  // A species or role word in `kind` reads as its kind; the word is kept as the type.
+  const KIND_WORDS = [
+    ['player', /^(player|hero|avatar|me|you)$/i],
+    ['person', /person|people|folk|npc|villager|towns|guard|human|man$|woman|child|kid|crowd|worker|vendor|keeper|citizen|pedestrian|walker|merchant|farmer|soldier/i],
+    ['machine', /machine|drone|robot|crane|vehicle|car$|truck|ship|boat|cart|train|mech|turret|nanny/i],
+    ['creature', /creature|animal|beast|monster|crab|bird|fox|dog|hound|cat$|fish|moth|goat|wader|whale|wolf|bug|insect|critter|horse|cow|sheep|kite|gull|bat$|deer|rabbit|pig|chicken|duck|owl|crow|butterfl/i],
+    ['prop', /prop|crate|box|barrel|rock|tree|bush|house|hut|shack|stall|wall|fence|post|pole|sign|bench|table|container|booth|tower|mast/i],
+  ];
+  const kindOf = (k) => { const w = String(k ?? ''); if (KINDS.includes(w)) return w; const hit = KIND_WORDS.find(([, re]) => re.test(w)); return hit ? hit[0] : 'prop'; };
+  const where = (raw) => {
+    const p = raw.pos || raw.position || raw.feet;
+    if (Array.isArray(p)) return [num(p[0]), num(p[1]), num(p[2])];
+    if (p && typeof p === 'object') return [num(p.x), num(p.y), num(p.z)];
+    return [num(raw.x), num(raw.y), num(raw.z)];
+  };
+
+  const scene = window.__THREEJS_SCENE__ || (window.scene && window.scene.isScene ? window.scene : null);
+  const three = !!(scene && scene.isObject3D);
+  const app = window.__PIXI_APP__ || (window.__PIXI_DEVTOOLS__ && window.__PIXI_DEVTOOLS__.app) || null;
+  out.engine = three ? 'three' : app ? 'pixi' : 'none';
+
+  if (list) {
+    out.source = 'contract';
+    for (const raw of list) {
+      if (out.actors.length >= MAX) break;
+      if (!raw || typeof raw !== 'object') continue;
+      const [x, y, z0] = where(raw), z = z0 ?? 0;
+      if (x === null || y === null) continue;
+      const r = num(raw.r);
+      const w = num(raw.w) ?? (r !== null ? 2 * r : null), d = num(raw.d) ?? (r !== null ? 2 * r : w);
+      const kind = kindOf(raw.kind ?? raw.role ?? raw.type);
+      const id = String(raw.id ?? `${kind}-${out.actors.length}`);
+      const word = String(raw.kind ?? '');
+      const type = typeof raw.type === 'string' && raw.type ? raw.type : typeof raw.species === 'string' && raw.species ? raw.species
+        : word && !KINDS.includes(word) ? word : typeof raw.role === 'string' && raw.role ? raw.role : id.replace(/[-_:#. ]?\d+.*$/, '').replace(/[-_:#. ]+$/, '');
+      const one = {
+        id, kind, type,
+        x, y, z, w, h: num(raw.h ?? raw.height), d, r: r ?? (w !== null && d !== null ? Math.min(w, d) / 2 : null),
+        ground: num(raw.ground), grounded: typeof raw.grounded === 'boolean' ? raw.grounded : null,
+        flies: raw.flies === true || raw.flying === true, solid: raw.solid !== false, state: raw.state === undefined || raw.state === null ? null : String(raw.state).slice(0, 40),
+        node: typeof raw.node === 'string' ? raw.node : '', screen: null,
+        ...(typeof raw.task === 'string' ? { task: raw.task.slice(0, 40) } : {}),
+        ...(raw.reacting ? { reacting: String(raw.reacting).slice(0, 40) } : {}),
+        ...(typeof (raw.scene ?? raw.group) === 'string' && (raw.scene ?? raw.group) ? { scene: String(raw.scene ?? raw.group).slice(0, 40) } : {}),
+        ...(raw.landed === true ? { landed: true } : {}),
+        ...(num(raw.facing ?? raw.heading) !== null ? { facing: num(raw.facing ?? raw.heading) } : {}),
+      };
+      if (want(one)) out.actors.push(one);
+    }
+  }
+
+  // --- the scene fallback: named nodes, boxed as posed now -------------------
+  // The box is the actor's OWN model (one game, 7 Oct: the hero read 0% tall and counted what it carried):
+  // a node under a person, creature or machine named as a prop (a crate on a cart) is its own prop, and in a
+  // rigged model the body is what the skeleton moves, so a static mesh under it (a lantern in a hand) is carried.
+  // A skinned mesh is boxed from its vertices through its bones: its geometry's box is the bind pose, and a
+  // quantized GLB (the optimizer's meshopt, every rigged model) keeps raw integers there, the scale baked into
+  // the bones, so that box read a 1.7 m hero as a few centimetres. Without a bone transform, the bones' places.
+  const V = three ? scene.position.constructor : null;
+  const SKIN_SAMPLES = 2000;
+  const worldBox = (o, other) => {
+    const b = { min: { x: Infinity, y: Infinity, z: Infinity }, max: { x: -Infinity, y: -Infinity, z: -Infinity } };
+    const grow = (p) => {
+      b.min.x = Math.min(b.min.x, p.x); b.min.y = Math.min(b.min.y, p.y); b.min.z = Math.min(b.min.z, p.z);
+      b.max.x = Math.max(b.max.x, p.x); b.max.y = Math.max(b.max.y, p.y); b.max.z = Math.max(b.max.z, p.z);
+    };
+    // What the box counts: no node `other` names (a prop under it; never a bone); in a rigged model, its skinned meshes.
+    const apart = (m, top) => !top && !m.isBone && !!other && other(m.name || '');
+    let rigged = false, skipped = false, looked = 0;
+    const scan = (m, top) => {
+      if (m.visible === false || looked++ > 400) return;
+      if (apart(m, top)) { skipped = true; return; }
+      if (m.isSkinnedMesh) rigged = true;
+      for (const c of m.children || []) scan(c, false);
+    };
+    scan(o, true);
+    const skinned = (m) => {
+      const pos = m.geometry && m.geometry.attributes && m.geometry.attributes.position;
+      const bone = m.applyBoneTransform || m.boneTransform;
+      if (pos && typeof bone === 'function' && typeof pos.getX === 'function') {
+        try {
+          const step = Math.max(1, Math.ceil(pos.count / SKIN_SAMPLES));
+          for (let i = 0; i < pos.count; i += step) grow(bone.call(m, i, new V(pos.getX(i), pos.getY(i), pos.getZ(i))).applyMatrix4(m.matrixWorld));
+          return true;
+        } catch { /* no skin attributes: the bones below */ }
+      }
+      const bones = (m.skeleton && m.skeleton.bones) || [];
+      for (const k of bones) { const e = k.matrixWorld && k.matrixWorld.elements; if (e) grow({ x: e[12], y: e[13], z: e[14] }); }
+      return bones.length > 0;
+    };
+    let n = 0;
+    // `all`: when that leaves nothing to box (every mesh under a name that reads as a prop), box it all.
+    const visit = (m, top, all) => {
+      if (m.visible === false || n > 400) return;
+      if (!all && apart(m, top)) return;
+      n++;
+      const body = all || !rigged || m.isSkinnedMesh;
+      if (m.isSprite) {
+        if (body) {
+          const e = m.matrixWorld.elements, sx = Math.hypot(e[0], e[1], e[2]) / 2, sy = Math.hypot(e[4], e[5], e[6]) / 2;
+          grow({ x: e[12] - sx, y: e[13] - sy, z: e[14] - sx }); grow({ x: e[12] + sx, y: e[13] + sy, z: e[14] + sx });
+        }
+      } else if (m.isSkinnedMesh && skinned(m)) {
+        // boxed as posed
+      } else if ((m.isMesh || m.isSkinnedMesh) && m.geometry && !m.isInstancedMesh && body) {
+        const g = m.geometry;
+        if (!g.boundingBox && g.computeBoundingBox) g.computeBoundingBox();
+        const bb = g.boundingBox;
+        if (bb) {
+          for (let i = 0; i < 8; i++) {
+            const p = new V(i & 1 ? bb.max.x : bb.min.x, i & 2 ? bb.max.y : bb.min.y, i & 4 ? bb.max.z : bb.min.z).applyMatrix4(m.matrixWorld);
+            grow(p);
+          }
+        }
+      }
+      for (const c of m.children || []) visit(c, false, all);
+    };
+    visit(o, true, false);
+    if (!Number.isFinite(b.min.x) && skipped) { n = 0; visit(o, true, true); }
+    return Number.isFinite(b.min.x) ? b : null;
+  };
+
+  if (!list && three) {
+    out.source = 'scene';
+    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|crowd|worker|vendor|keeper', 'i'),
+      creature: new RegExp(a.creatures || 'creature|animal|beast|monster|crab|bird|fox|dog|hound|cat|fish|moth|goat|wader|whale|wolf|bug|insect|critter|horse|cow|sheep|gull|kite|bat\\b|owl|crow|deer|rabbit|duck|chicken|pig\\b|butterfl', 'i'),
+      machine: new RegExp(a.machines || 'drone|robot|machine|crane|vehicle|car|truck|ship|boat|nanny|mech|turret', 'i'),
+      prop: new RegExp(a.props || 'prop|crate|box|barrel|rock|boulder|tree|bush|house|hut|shack|stall|wall|fence|post|pole|sign|bench|table|container|booth|tower|mast', 'i'),
+    };
+    scene.updateMatrixWorld && scene.updateMatrixWorld();
+    const seen = new Map();
+    const walk = (o, depth) => {
+      if (!o || o.visible === false || out.actors.length >= MAX || depth > 12) return;
+      const name = o.name || '';
+      const kind = name ? KINDS.find((k) => pat[k].test(name)) : null;
+      if (kind && !o.isScene && !o.isCamera && !o.isLight) {
+        const b = worldBox(o, kind === 'prop' ? null : (nm) => pat.prop.test(nm));
+        if (b) {
+          const k = seen.get(name) || 0;
+          seen.set(name, k + 1);
+          const w = b.max.x - b.min.x, d = b.max.z - b.min.z;
+          const one = {
+            id: k ? `${name}#${k}` : name, kind, type: name, x: (b.min.x + b.max.x) / 2, y: b.min.y, z: (b.min.z + b.max.z) / 2,
+            w, h: b.max.y - b.min.y, d, r: Math.min(w, d) / 2, ground: null, grounded: null, flies: false, solid: true, state: null, node: name, screen: null,
+          };
+          if (want(one)) out.actors.push(one);
+        }
+        return;
+      }
+      for (const c of o.children || []) walk(c, depth + 1);
+    };
+    walk(scene, 0);
+  }
+
+  // --- which way each person or creature faces (lane J4: two neighbours talking face each other) ---------
+  // The contract's `facing` (radians, the world yaw of its forward: atan2(forward.x, forward.z)), else its node's
+  // forward (+z of the node as turned), the node of that name nearest its feet.
+  if (three && out.actors.some((t) => (t.kind === 'person' || t.kind === 'creature') && t.facing === undefined && t.node)) {
+    const byName = new Map();
+    scene.traverse((o) => { if (o.name) { const l = byName.get(o.name) || []; l.push(o); byName.set(o.name, l); } });
+    for (const t of out.actors) {
+      if ((t.kind !== 'person' && t.kind !== 'creature') || t.facing !== undefined || !t.node) continue;
+      const l = byName.get(t.node); if (!l) continue;
+      let best = null, bd = Infinity;
+      for (const o of l) { const e = o.matrixWorld.elements, d = Math.hypot(e[12] - t.x, e[14] - t.z); if (d < bd) { bd = d; best = o; } }
+      if (!best || bd > 3) continue;
+      const e = best.matrixWorld.elements;
+      if (Math.hypot(e[8], e[10]) > 1e-6) t.facing = Math.round(Math.atan2(e[8], e[10]) * 1000) / 1000;
+    }
+  }
+
+  // --- where each lands on screen (Three) ------------------------------------
+  const cam = window.camera || window.__THREEJS_CAMERA__ || null;
+  const ren = window.__THREEJS_RENDERER__ || window.renderer;
+  const canvas = (ren && ren.domElement) || document.querySelector('canvas');
+  if (three && cam && cam.isCamera && canvas) {
+    const rect = canvas.getBoundingClientRect();
+    out.view = { width: Math.round(rect.width), height: Math.round(rect.height) };
+    cam.updateMatrixWorld && cam.updateMatrixWorld();
+    for (const t of out.actors) {
+      if (t.h === null) continue;
+      const hw = (t.w ?? 0) / 2, hd = (t.d ?? 0) / 2;
+      let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity, front = 0;
+      for (let i = 0; i < 8; i++) {
+        const p = new V(t.x + (i & 1 ? hw : -hw), t.y + (i & 2 ? t.h : 0), t.z + (i & 4 ? hd : -hd)).project(cam);
+        if (p.z < 1 && p.z > -1) front++;
+        const sx = rect.left + ((p.x + 1) / 2) * rect.width, sy = rect.top + ((1 - p.y) / 2) * rect.height;
+        x0 = Math.min(x0, sx); x1 = Math.max(x1, sx); y0 = Math.min(y0, sy); y1 = Math.max(y1, sy);
+      }
+      if (!front) { t.screen = { x: 0, y: 0, w: 0, h: 0, share: 0, on: false }; continue; }
+      const on = x1 > rect.left && x0 < rect.right && y1 > rect.top && y0 < rect.bottom;
+      t.screen = { x: Math.round(x0), y: Math.round(y0), w: Math.round(x1 - x0), h: Math.round(y1 - y0), share: Math.round(((y1 - y0) / (rect.height || 1)) * 1000) / 1000, on };
+    }
+  }
+  for (const t of out.actors) for (const k of ['x', 'y', 'z', 'w', 'h', 'd', 'r', 'ground']) if (typeof t[k] === 'number') t[k] = Math.round(t[k] * 1000) / 1000;
+  return JSON.stringify(out);
+}

package/dist/verify/browser.js

@@ -0,0 +1,245 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { previewShim } from '../vendor/verify/src/index.js';
+import { gpuArgs } from "./gpu.js";
+export const SWIFTSHADER_FLAGS = [
+    '--use-gl=angle',
+    '--use-angle=swiftshader',
+    '--enable-unsafe-swiftshader',
+    '--ignore-gpu-blocklist',
+    '--enable-webgl',
+    '--enable-webgl2',
+];
+function browsersPath(pkgDir) {
+    const env = process.env.PLAYWRIGHT_BROWSERS_PATH;
+    if (env === '0')
+        return join(pkgDir, '.local-browsers');
+    if (env)
+        return env;
+    if (process.platform === 'darwin')
+        return join(homedir(), 'Library', 'Caches', 'ms-playwright');
+    if (process.platform === 'win32')
+        return join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'ms-playwright');
+    return join(process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), 'ms-playwright');
+}
+export function headlessShell() {
+    return pinned('chromium-headless-shell', 'chromium_headless_shell', 'chromium');
+}
+export function headlessShellExecutable() {
+    const pkgDir = dirname(createRequire(import.meta.url).resolve('playwright-core/package.json'));
+    const browsers = JSON.parse(readFileSync(join(pkgDir, 'browsers.json'), 'utf8')).browsers;
+    const rev = browsers.find((b) => b.name === 'chromium-headless-shell')?.revision;
+    if (!rev)
+        return null;
+    const root = join(browsersPath(pkgDir), `chromium_headless_shell-${rev}`);
+    const exe = process.platform === 'win32' ? 'chrome-headless-shell.exe' : 'chrome-headless-shell';
+    let dirs = [];
+    try {
+        dirs = readdirSync(root).filter((d) => d.startsWith('chrome-headless-shell'));
+    }
+    catch {
+        return null;
+    }
+    const file = dirs.map((d) => join(root, d, exe)).find((f) => existsSync(f));
+    return file ?? null;
+}
+export function webkitBuild() {
+    return pinned('webkit', 'webkit', 'webkit');
+}
+function pinned(name, dir, installName) {
+    const pkgDir = dirname(createRequire(import.meta.url).resolve('playwright-core/package.json'));
+    const version = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')).version;
+    const install = `npx playwright@${version} install ${installName}`;
+    const browsers = JSON.parse(readFileSync(join(pkgDir, 'browsers.json'), 'utf8')).browsers;
+    const rev = browsers.find((b) => b.name === name)?.revision;
+    return { installed: !!rev && existsSync(join(browsersPath(pkgDir), `${dir}-${rev}`)), install };
+}
+export const ENGINES = ['chromium', 'webkit'];
+export function engine(env = process.env) {
+    return env.FUNTOOLS_ENGINE === 'webkit' ? 'webkit' : 'chromium';
+}
+export function webkitCheck(build = () => webkitBuild()) {
+    try {
+        const w = build();
+        return w.installed
+            ? ['pass', "Playwright's WebKit (Safari's engine): `--engine webkit` on verify, capture, play, journey and feel"]
+            : ['note', `Safari's engine, optional: ${w.install} — then \`--engine webkit\` looks at a Safari-only bug on this machine`];
+    }
+    catch {
+        return ['note', 'playwright-core is not available — no WebKit check'];
+    }
+}
+const CHROME = {
+    darwin: ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'],
+    linux: ['/opt/google/chrome/chrome', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable'],
+    win32: [join(process.env.PROGRAMFILES ?? 'C:\\Program Files', 'Google', 'Chrome', 'Application', 'chrome.exe')],
+};
+export function browserCheck() {
+    try {
+        const shell = headlessShell();
+        if (shell.installed)
+            return ['pass', "Playwright's headless Chromium, the browser the hosted probe runs"];
+        const chrome = (CHROME[process.platform] ?? []).some((p) => existsSync(p));
+        return chrome
+            ? ['warn', `Playwright's headless Chromium is not installed, so verify falls back to your Chrome — install it: ${shell.install}`]
+            : ['fail', `no browser for verify — install one: ${shell.install}`];
+    }
+    catch {
+        return ['warn', 'playwright-core is not available — verify cannot run (npm install in funtools)'];
+    }
+}
+export function chromeFallbackNote(install = headlessShell().install) {
+    return ['note', `ran on your Chrome (Playwright's headless Chromium is not installed); the verdict stands. Only if the server's verify at publish disagrees, install the probe's browser: ${install}`];
+}
+export async function launch(software = false, ownSigint = false, headed = false) {
+    const { chromium, webkit } = await import('playwright-core');
+    if (engine() === 'webkit') {
+        try {
+            return { browser: await webkit.launch({ headless: !headed, handleSIGINT: !ownSigint }), chrome: false };
+        }
+        catch (e) {
+            const w = webkitBuild();
+            throw new Error(w.installed ? `WebKit did not start: ${String(e?.message ?? e).split('\n')[0]}` : `--engine webkit: Playwright's WebKit is not installed — install it: ${w.install}`);
+        }
+    }
+    const opts = { headless: !headed, args: software ? SWIFTSHADER_FLAGS : gpuArgs(), handleSIGINT: !ownSigint };
+    try {
+        return { browser: await chromium.launch(opts), chrome: false };
+    }
+    catch {
+        try {
+            return { browser: await chromium.launch({ ...opts, channel: 'chrome' }), chrome: true };
+        }
+        catch {
+            throw new Error(`no browser for verify: Playwright's Chromium is not installed and there is no Chrome — install it: ${headlessShell().install}`);
+        }
+    }
+}
+export const VIEWPORT_CHOICES = ['desktop', 'phone', 'both'];
+export const SAFARI_PAGE = { portrait: { width: 390, height: 684 }, landscape: { width: 724, height: 283 } };
+export function viewportOptions(name, orientation = '', safari = false) {
+    if (name === 'desktop')
+        return { viewport: { width: 1280, height: 720 } };
+    const landscape = orientation.trim().toLowerCase() === 'landscape';
+    return {
+        viewport: safari ? { ...SAFARI_PAGE[landscape ? 'landscape' : 'portrait'] } : landscape ? { width: 844, height: 390 } : { width: 390, height: 844 },
+        deviceScaleFactor: 2,
+        isMobile: true,
+        hasTouch: true,
+    };
+}
+export const viewportsFor = (choice) => (choice === 'both' ? ['desktop', 'phone'] : [choice]);
+export function viewportUrl(url, name) {
+    if (name !== 'phone' || /[?&]funpixel_touch=1\b/.test(url))
+        return url;
+    const [base, hash] = url.split('#', 2);
+    return `${base}${base.includes('?') ? '&' : '?'}funpixel_touch=1${hash === undefined ? '' : `#${hash}`}`;
+}
+export function withPreviewShim(html) {
+    if (html.includes('funpixel-touch-emu'))
+        return html;
+    const tag = `<script id="funpixel-touch-emu">\n${previewShim()}\n</script>`;
+    const head = /<head[^>]*>/i.exec(html);
+    if (head)
+        return html.slice(0, head.index + head[0].length) + tag + html.slice(head.index + head[0].length);
+    const doctype = /^\s*<!doctype[^>]*>/i.exec(html);
+    return doctype ? doctype[0] + tag + html.slice(doctype[0].length) : tag + html;
+}
+export async function lookPage(browser, name, orientation = '', safari = false) {
+    const context = await browser.newContext(viewportOptions(name, orientation, safari));
+    if (name === 'phone') {
+        await context.route((url) => url.searchParams.get('funpixel_touch') === '1', async (route) => {
+            if (route.request().resourceType() !== 'document')
+                return route.fallback();
+            const res = await route.fetch().catch(() => null);
+            if (!res)
+                return route.fallback();
+            const type = res.headers()['content-type'] ?? '';
+            if (!type.includes('html'))
+                return route.fulfill({ response: res });
+            return route.fulfill({ response: res, body: withPreviewShim(await res.text()) });
+        });
+    }
+    return context.newPage();
+}
+export async function touchSession(page) {
+    if (engine() !== 'webkit')
+        return page.context().newCDPSession(page);
+    const pending = new Map();
+    const live = new Set();
+    const synth = (type, pts) => page.evaluate(`(${SYNTH_TOUCH})(${JSON.stringify({ type, pts })})`).catch(() => { });
+    return {
+        async send(_method, { type, touchPoints }) {
+            const pts = touchPoints.map((p, i) => ({ x: p.x, y: p.y, id: p.id ?? i }));
+            if (type === 'touchStart') {
+                for (const p of pts)
+                    pending.set(p.id, { ...p, at: Date.now() });
+                return;
+            }
+            if (type === 'touchMove') {
+                const still = (p) => { const s = pending.get(p.id); return Math.hypot(p.x - s.x, p.y - s.y) < 2 && Date.now() - s.at < 250; };
+                const starting = pts.filter((p) => pending.has(p.id) && !still(p));
+                if (!starting.length && pts.every((p) => pending.has(p.id)))
+                    return;
+                if (starting.length) {
+                    await synth('start', starting.map((p) => ({ ...pending.get(p.id), id: p.id })));
+                    for (const p of starting) {
+                        pending.delete(p.id);
+                        live.add(p.id);
+                    }
+                }
+                return synth('move', pts.filter((p) => !pending.has(p.id)));
+            }
+            const ending = pts.length ? pts : [...[...pending].map(([id, p]) => ({ ...p, id })), ...[...live].map((id) => ({ x: 0, y: 0, id }))];
+            for (const p of ending) {
+                const start = pending.get(p.id);
+                if (start && Date.now() - start.at < 250) {
+                    pending.delete(p.id);
+                    await page.touchscreen.tap(start.x, start.y);
+                    continue;
+                }
+                if (start) {
+                    await synth('start', [{ ...start, id: p.id }]);
+                    pending.delete(p.id);
+                }
+                live.delete(p.id);
+                await synth('end', [p]);
+            }
+        },
+    };
+}
+const SYNTH_TOUCH = `({ type, pts }) => {
+  const P = { start: ['pointerdown', 'touchstart'], move: ['pointermove', 'touchmove'], end: ['pointerup', 'touchend'] }[type];
+  window.__fpxTouch = window.__fpxTouch || {};
+  for (const p of pts) {
+    const el = (type === 'start' ? document.elementFromPoint(p.x, p.y) : window.__fpxTouch[p.id]) || document.elementFromPoint(p.x, p.y) || document.body;
+    if (type === 'start') window.__fpxTouch[p.id] = el;
+    const init = { bubbles: true, cancelable: true, composed: true, clientX: p.x, clientY: p.y, pointerId: 10 + p.id, pointerType: 'touch', isPrimary: p.id === 0, button: 0, buttons: type === 'end' ? 0 : 1 };
+    el.dispatchEvent(new PointerEvent(P[0], init));
+    try {
+      const t = new Touch({ identifier: p.id, target: el, clientX: p.x, clientY: p.y });
+      const alive = type === 'end' ? [] : [t];
+      el.dispatchEvent(new TouchEvent(P[1], { bubbles: true, cancelable: true, touches: alive, targetTouches: alive, changedTouches: [t] }));
+    } catch (e) { /* no Touch constructor: pointer events only */ }
+    if (type === 'end') delete window.__fpxTouch[p.id];
+  }
+}`;
+export async function webglAvailable(page) {
+    try {
+        return await page.evaluate(`(() => { const c = document.createElement('canvas');
+      return !!(c.getContext('webgl2') || c.getContext('webgl')); })()`) === true;
+    }
+    catch {
+        return true;
+    }
+}
+export function glTrouble(report, webgl) {
+    const h = report.render_health;
+    if (h?.context_loss_observed && h.context_lost)
+        return 'the graphics context was lost';
+    if (!webgl && h?.canvas_observed)
+        return 'this browser has no WebGL (no usable GPU)';
+    return null;
+}

package/dist/verify/console.js

@@ -0,0 +1,34 @@
+const MAX_SHOWN = 3;
+const MAX_CHARS = 200;
+export function consoleWitness(skip) {
+    const lines = [];
+    return {
+        attach(page) {
+            page.on('console', (m) => { if (m.type() === 'error' && !skip?.(m.text(), m.location()?.url ?? ''))
+                lines.push(m.text()); });
+            page.on('pageerror', (e) => lines.push(`uncaught: ${e.message}`));
+        },
+        errors: () => summarizeConsole(lines),
+    };
+}
+export function summarizeConsole(lines) {
+    const unique = [];
+    for (const l of lines) {
+        const one = l.replace(/\s+/g, ' ').trim();
+        const cut = one.length > MAX_CHARS ? `${one.slice(0, MAX_CHARS - 1)}…` : one;
+        if (cut && !unique.includes(cut))
+            unique.push(cut);
+    }
+    return { count: lines.length, unique };
+}
+export function consoleNote(e) {
+    if (!e.count)
+        return null;
+    const isShader = (l) => /shader error|webglprogram|not compiled/i.test(l);
+    const shader = e.unique.some(isShader);
+    const ordered = [...e.unique.filter(isShader), ...e.unique.filter((l) => !isShader(l))];
+    const head = `the page logged ${e.count} console error(s)${shader ? ' — a shader failed to compile: whatever uses it draws as nothing' : ''}`;
+    const shown = ordered.slice(0, MAX_SHOWN).map((l) => `"${l}"`).join('; ');
+    const more = e.unique.length > MAX_SHOWN ? ` (+${e.unique.length - MAX_SHOWN} more in verify.json)` : '';
+    return `${head}: ${shown}${more}`;
+}

package/dist/verify/fingerprint.js

@@ -0,0 +1,72 @@
+import { createHash } from 'node:crypto';
+import { createReadStream, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { stageFiles } from "../stage/stage.js";
+const RECORD = 'verify.json';
+const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export function fingerprintOfDigests(digests) {
+    const h = createHash('sha256');
+    for (const { path, digest } of [...digests].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))) {
+        h.update(path).update('\0').update(digest).update('\n');
+    }
+    return `sha256:${h.digest('hex')}`;
+}
+export function fingerprintOf(entries) {
+    return fingerprintOfDigests(entries.map(({ path, bytes }) => ({ path, digest: sha256(bytes) })));
+}
+const AT_ONCE = 32;
+export async function stagedEntries(root) {
+    const files = stageFiles(root).included.filter((f) => f !== RECORD);
+    const entries = [];
+    for (let i = 0; i < files.length; i += AT_ONCE) {
+        entries.push(...await Promise.all(files.slice(i, i + AT_ONCE).map(async (path) => ({ path, bytes: await readFile(join(root, path)) }))));
+    }
+    return entries;
+}
+function digestOf(file) {
+    return new Promise((done, fail) => {
+        const h = createHash('sha256');
+        createReadStream(file).on('error', fail).on('data', (chunk) => h.update(chunk)).on('end', () => done(h.digest('hex')));
+    });
+}
+export class HashBudgetExceeded extends Error {
+    hashed;
+    staged;
+    constructor(hashed, staged) {
+        super(`hashed ${hashed} of ${staged} files before the deadline`);
+        this.hashed = hashed;
+        this.staged = staged;
+    }
+}
+export async function stagedDigests(root, cache, until) {
+    const files = stageFiles(root).included.filter((f) => f !== RECORD);
+    const digests = [];
+    for (let i = 0; i < files.length; i += AT_ONCE) {
+        if (until !== undefined && Date.now() > until)
+            throw new HashBudgetExceeded(i, files.length);
+        digests.push(...await Promise.all(files.slice(i, i + AT_ONCE).map(async (path) => {
+            const file = join(root, path);
+            if (!cache)
+                return { path, digest: await digestOf(file) };
+            const { size, mtimeMs } = statSync(file);
+            const was = cache[path];
+            if (was && was[0] === size && was[1] === mtimeMs)
+                return { path, digest: was[2] };
+            const digest = await digestOf(file);
+            cache[path] = [size, mtimeMs, digest];
+            return { path, digest };
+        })));
+    }
+    if (cache) {
+        const staged = new Set(files);
+        for (const path of Object.keys(cache))
+            if (!staged.has(path))
+                delete cache[path];
+    }
+    return digests;
+}
+export async function fingerprint(root, cache) {
+    const digests = await stagedDigests(root, cache);
+    return { fingerprint: fingerprintOfDigests(digests), files: digests.length };
+}

package/dist/verify/gpu.js

@@ -0,0 +1,33 @@
+export const GPU_FLAGS = ['--use-angle=metal', '--enable-gpu', '--ignore-gpu-blocklist'];
+export function gpuArgs(platform = process.platform) {
+    return platform === 'darwin' ? GPU_FLAGS : [];
+}
+export const SOFTWARE_RENDERER = /swiftshader|llvmpipe|softpipe|lavapipe|software|basic render/i;
+export const NO_RENDERER = { renderer: null, software: null };
+export function rendererFact(name) {
+    if (typeof name !== 'string' || !name.trim())
+        return NO_RENDERER;
+    return { renderer: name.trim(), software: SOFTWARE_RENDERER.test(name) };
+}
+const READ = `(() => { try {
+  const c = document.createElement('canvas');
+  const gl = c.getContext('webgl2') || c.getContext('webgl');
+  if (!gl) return null;
+  const d = gl.getExtension('WEBGL_debug_renderer_info');
+  const name = d ? gl.getParameter(d.UNMASKED_RENDERER_WEBGL) : null;
+  const lose = gl.getExtension('WEBGL_lose_context'); if (lose) lose.loseContext();
+  return typeof name === 'string' ? name : null;
+} catch (e) { return null; } })()`;
+export async function rendererOf(page) {
+    return rendererFact(await page.evaluate(READ).catch(() => null));
+}
+export function timingVoid(f, asked = false) {
+    if (asked || f.software !== true)
+        return null;
+    return `rendered on ${f.renderer} (software: the CPU drew every frame), so frame times, fps and anything timed are this machine's fallback, not the game's — not observed. Run it where Chromium gets a GPU (on macOS funtools passes ${GPU_FLAGS.join(' ')}; a headless Linux box has none)`;
+}
+export function rendererLine(f, asked = false) {
+    if (f.renderer === null)
+        return 'renderer not observed (no WebGL, or the name is masked)';
+    return `renderer ${f.renderer}${f.software ? (asked ? ' (software GL, as asked)' : ' (SOFTWARE)') : ''}`;
+}