meshpad 0.0.0-stage → 0.1.0

package/src/capture.js

@@ -0,0 +1,143 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, extname, resolve } from 'node:path';
+import { chromium } from 'playwright';
+import { startDev } from './tooling.js';
+
+const pngPath = (path) => {
+  if (typeof path !== 'string' || extname(path).toLowerCase() !== '.png') throw new Error('Screenshot output must end in .png.');
+  return path;
+};
+
+/** Validate the whole script before launching a game or writing screenshots. */
+export function validateSteps(steps) {
+  if (!Array.isArray(steps)) throw new TypeError('Script must be a JSON array of steps.');
+  for (const [index, step] of steps.entries()) {
+    try {
+      if (!step || typeof step !== 'object' || Array.isArray(step)) throw new Error('Expected a step object.');
+      switch (step.type) {
+        case 'pointerdown': case 'pointermove': case 'pointerup':
+          if (step.type === 'pointerup' && step.world === undefined) break;
+          if (!Array.isArray(step.world) || step.world.length !== 3 || !step.world.every(Number.isFinite)) {
+            throw new Error('world must be [x, y, z] with finite coordinates.');
+          }
+          break;
+        case 'advance':
+          if (!Number.isFinite(step.seconds) || step.seconds < 0 || step.seconds > 60) throw new Error('seconds must be between 0 and 60.');
+          break;
+        case 'screenshot': pngPath(step.output); break;
+        case 'state':
+          if (step.label !== undefined && typeof step.label !== 'string') throw new Error('label must be a string.');
+          break;
+        default: throw new Error(`Unknown step type: ${step.type}.`);
+      }
+    } catch (error) { throw new Error(`Script step ${index + 1}: ${error.message}`, { cause: error }); }
+  }
+  return steps;
+}
+
+/** Render and scripted play share the same browser, clock, input, and capture path. */
+export async function captureGame(entry, options = {}) {
+  const width = options.width ?? 390;
+  const height = options.height ?? 844;
+  const dpr = options.dpr ?? 1;
+  const time = options.time ?? 0;
+  const level = options.level ?? 1;
+  const timeout = options.timeout ?? 30000;
+  for (const [name, size] of Object.entries({ width, height })) {
+    if (!Number.isInteger(size) || size < 1 || size > 4096) throw new RangeError(`${name} must be an integer from 1 to 4096.`);
+  }
+  if (!Number.isFinite(dpr) || dpr < 0.25 || dpr > 4) throw new RangeError('dpr must be between 0.25 and 4.');
+  if (!Number.isFinite(time) || time < 0 || time > 60) throw new RangeError('time must be between 0 and 60 seconds.');
+  if (!Number.isInteger(level) || level < 1) throw new RangeError('level must be a positive integer (starting at 1).');
+  if (!Number.isInteger(timeout) || timeout < 1) throw new RangeError('timeout must be a positive integer in milliseconds.');
+  const output = resolve(pngPath(options.output ?? 'renders/game.png'));
+  const scriptPath = options.script ? resolve(options.script) : null;
+  const steps = scriptPath ? validateSteps(JSON.parse(await readFile(scriptPath, 'utf8'))) : [];
+  const server = await startDev(entry, { root: options.root, port: 0, logLevel: 'error' });
+  let browser;
+  try {
+    try {
+      browser = await chromium.launch({ headless: true, args: ['--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    } catch (error) {
+      throw new Error('Could not launch Chromium. Run "meshpad browsers" once (Linux CI: "meshpad browsers --with-deps").', { cause: error });
+    }
+    const page = await browser.newPage({ viewport: { width, height }, deviceScaleFactor: dpr });
+    page.setDefaultTimeout(timeout);
+    const errors = [];
+    page.on('pageerror', (error) => errors.push(error.message));
+    const address = server.httpServer.address();
+    await page.goto(`http://127.0.0.1:${address.port}/?__meshpad_capture&__meshpad_dpr=${dpr}`, { waitUntil: 'load', timeout });
+    await page.waitForFunction(() => Boolean(window.__MESHPAD__), null, { timeout });
+    // Bound asynchronous user setup as well as browser navigation.
+    await page.evaluate(async ({ level, time, timeout }) => {
+      const run = async () => {
+        const game = window.__MESHPAD__;
+        await game.ready;
+        if (game.state.index !== level - 1) await game.loadLevel(level - 1);
+        await document.fonts.ready;
+        if (time > 0) game.step(time);
+      };
+      let timer;
+      try {
+        await Promise.race([run(), new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('Game setup timed out.')), timeout); })]);
+      } finally { clearTimeout(timer); }
+    }, { level, time, timeout });
+
+    const inspect = async () => {
+      if (errors.length) throw new Error(`Game failed: ${errors.join('\n')}`);
+      return page.evaluate(() => {
+        const game = window.__MESHPAD__;
+        if (game.state.status === 'error') throw game.state.error;
+        let debug;
+        try { debug = JSON.parse(JSON.stringify(game.debug())); }
+        catch (error) { throw new Error(`debug() must return JSON-serializable state: ${error.message}`); }
+        return {
+          state: { ...game.state, error: null }, debug,
+          three: { calls: game.renderer.info.render.calls, triangles: game.renderer.info.render.triangles },
+        };
+      });
+    };
+    const metadata = { width, height, dpr, level, time };
+    if (options.sceneOnly) await page.locator('.meshpad-hud').evaluate((element) => { element.style.display = 'none'; });
+    const save = async (path, extra = {}) => {
+      await page.evaluate(() => window.__MESHPAD__.step(0));
+      const result = { ...metadata, ...await inspect(), ...extra };
+      await mkdir(dirname(path), { recursive: true });
+      await page.locator(options.sceneOnly ? '.meshpad-canvas' : '.meshpad-stage').screenshot({ path, timeout, animations: 'disabled' });
+      await writeFile(path.slice(0, -4) + '.json', JSON.stringify(result, null, 2) + '\n');
+      return { output: path, ...result };
+    };
+    await inspect();
+    const snapshots = [];
+    for (const [index, step] of steps.entries()) {
+      try {
+        if (step.type.startsWith('pointer')) {
+          if (step.world) {
+            const point = await page.evaluate((world) => {
+              const game = window.__MESHPAD__;
+              game.camera.updateWorldMatrix(true, false);
+              const point = game.camera.position.clone().set(...world).project(game.camera);
+              if (![point.x, point.y, point.z].every(Number.isFinite) || Math.abs(point.z) > 1) throw new Error('World position is outside the camera depth range.');
+              const rect = game.renderer.domElement.getBoundingClientRect();
+              return { x: rect.left + (point.x + 1) * rect.width / 2, y: rect.top + (1 - point.y) * rect.height / 2 };
+            }, step.world);
+            await page.mouse.move(point.x, point.y);
+          }
+          if (step.type === 'pointerdown') await page.mouse.down();
+          if (step.type === 'pointerup') await page.mouse.up();
+        } else if (step.type === 'advance') {
+          await page.evaluate((seconds) => window.__MESHPAD__.step(seconds), step.seconds);
+        } else if (step.type === 'screenshot') {
+          const capture = await save(resolve(dirname(scriptPath), step.output));
+          snapshots.push({ step: index + 1, type: step.type, ...capture });
+        } else if (step.type === 'state') {
+          snapshots.push({ step: index + 1, type: step.type, ...(step.label === undefined ? {} : { label: step.label }), ...await inspect() });
+        }
+        await inspect();
+      } catch (error) { throw new Error(`Script step ${index + 1} (${step.type}): ${error.message}`, { cause: error }); }
+    }
+    return await save(output, scriptPath ? { snapshots } : {});
+  } finally {
+    try { await browser?.close(); } finally { await server.close(); }
+  }
+}

package/src/dispose.js

@@ -0,0 +1,26 @@
+// A level owns its scene resources. Deduplicate shared resources within a scene.
+export function disposeScene(scene) {
+  const resources = new Set();
+  const textures = new Set();
+  const collect = (value) => {
+    if (value?.isTexture) textures.add(value);
+    else if (Array.isArray(value)) value.forEach(collect);
+  };
+  scene.traverse((object) => {
+    if (object.geometry) resources.add(object.geometry);
+    if (object.skeleton) resources.add(object.skeleton);
+    if (object.shadow) resources.add(object.shadow);
+    for (const material of [object.material].flat().filter(Boolean)) {
+      resources.add(material);
+      Object.values(material).forEach(collect);
+      Object.values(material.uniforms ?? {}).forEach((uniform) => collect(uniform.value));
+    }
+  });
+  collect(scene.background);
+  collect(scene.environment);
+  for (const texture of textures) texture.dispose();
+  for (const resource of resources) resource.dispose();
+  scene.clear();
+  scene.background = null;
+  scene.environment = null;
+}

package/src/failure.js

@@ -0,0 +1,28 @@
+/** Validate and snapshot a failure mode before allocating a renderer. */
+export function createFailure(config = { type: 'default' }) {
+  if (!config || typeof config !== 'object') throw new TypeError('failure must be a failure mode object.');
+  const { type } = config;
+  if (type === 'default') return { type, initial: null, remaining: null, playOnAmount: null };
+  let initial;
+  let playOnAmount;
+  if (type === 'hearts') {
+    initial = config.hearts ?? 3;
+    if (!Number.isInteger(initial) || initial < 3 || initial > 5) throw new RangeError('failure.hearts must be 3, 4, or 5.');
+    playOnAmount = initial;
+  } else if (type === 'time') {
+    initial = config.seconds;
+    playOnAmount = config.playOnSeconds ?? 20;
+    if (![initial, playOnAmount].every((n) => Number.isFinite(n) && n > 0)) {
+      throw new RangeError('failure.seconds and failure.playOnSeconds must be positive finite numbers.');
+    }
+  } else if (type === 'moves') {
+    initial = config.moves;
+    playOnAmount = config.playOnMoves ?? 10;
+    if (![initial, playOnAmount].every((n) => Number.isSafeInteger(n) && n > 0)) {
+      throw new RangeError('failure.moves and failure.playOnMoves must be positive safe integers.');
+    }
+  } else {
+    throw new TypeError('failure.type must be default, hearts, time, or moves.');
+  }
+  return { type, initial, remaining: initial, playOnAmount };
+}

package/src/game.js

@@ -0,0 +1,311 @@
+import * as THREE from 'three';
+import { createHUD } from './hud.js';
+import { disposeScene } from './dispose.js';
+import { createFailure } from './failure.js';
+
+/** Create a mobile-first game. Every level gets its own scene and lifetime. */
+export function createGame(options = {}) {
+  const levels = options.levels;
+  if (!Array.isArray(levels) || levels.length === 0 || levels.some((level) => typeof level?.setup !== 'function')) {
+    throw new TypeError('Provide at least one level with a setup(context) function.');
+  }
+  if (levels.some((level) => level.difficulty !== undefined && !['normal', 'hard', 'very-hard', 'ultra-hard'].includes(level.difficulty))) {
+    throw new TypeError('Level difficulty must be normal, hard, very-hard, or ultra-hard.');
+  }
+  const initial = options.initialLevel ?? 0;
+  if (!Number.isInteger(initial) || initial < 0 || initial >= levels.length) throw new RangeError('initialLevel is out of range.');
+  const defaultFailure = createFailure(options.failure);
+  const failures = levels.map((level) => level.failure === undefined ? { ...defaultFailure } : createFailure(level.failure));
+  const maxPixelRatio = options.maxPixelRatio ?? 2;
+  const maxWidth = options.maxWidth ?? 540;
+  if (!(Number.isFinite(maxPixelRatio) && maxPixelRatio > 0 && Number.isFinite(maxWidth) && maxWidth > 0)) {
+    throw new RangeError('maxPixelRatio and maxWidth must be positive finite numbers.');
+  }
+  const root = typeof options.root === 'string' ? document.querySelector(options.root) : options.root ?? document.body;
+  if (!(root instanceof HTMLElement)) throw new Error('Game root was not found.');
+  if (root.querySelector('.meshpad-stage')) throw new Error('This root already contains a Meshpad game.');
+  const stage = document.createElement('main');
+  stage.className = 'meshpad-stage';
+  root.classList.add('meshpad-root');
+  root.append(stage);
+  let renderer;
+  try {
+    renderer = new THREE.WebGLRenderer({ antialias: true, alpha: false, powerPreference: 'high-performance', ...options.renderer });
+  } catch (error) {
+    stage.remove(); root.classList.remove('meshpad-root');
+    throw new Error('Meshpad needs a browser with WebGL 2 enabled.', { cause: error });
+  }
+  renderer.outputColorSpace = THREE.SRGBColorSpace;
+  renderer.toneMapping = THREE.ACESFilmicToneMapping;
+  renderer.domElement.className = 'meshpad-canvas';
+  renderer.domElement.setAttribute('aria-label', options.title ?? '3D game');
+  stage.append(renderer.domElement);
+  if (options.title) document.title = options.title;
+
+  const params = new URLSearchParams(location.search);
+  const capture = params.has('__meshpad_capture');
+  const captureDpr = capture ? Number(params.get('__meshpad_dpr')) : 0;
+  const lifetime = new AbortController();
+  const listen = (target, type, handler, extra = {}) => target.addEventListener(type, handler, { ...extra, signal: lifetime.signal });
+  let current;
+  let status = 'loading';
+  let disposed = false;
+  let contextLost = false;
+  let elapsed = 0;
+  let previousTime;
+  let frame = 0;
+  let resizeFrame = 0;
+  let generation = 0;
+  let width = 1;
+  let height = 1;
+  let manuallyPaused = false;
+  let levelMenuOpen = false;
+  let lastError = null;
+  const invoke = (callback) => { Promise.resolve().then(callback).catch(() => {}); };
+  const hud = createHUD(stage, levels, {
+    next: () => invoke(() => game.next()),
+    restart: () => invoke(() => game.restart()),
+    playOn: () => game.playOn(),
+    loadLevel: (index) => invoke(() => game.loadLevel(index)),
+    openLevels() {
+      levelMenuOpen = true;
+      if (status === 'playing') status = 'paused';
+      stopLoop();
+    },
+    closeLevels() {
+      levelMenuOpen = false;
+      if (status === 'paused' && !manuallyPaused) status = 'playing';
+      startLoop();
+    },
+  });
+  const isCurrent = (session) => Boolean(session) && !disposed && current === session && !session.controller.signal.aborted;
+  const report = (error, session = current) => {
+    if (!isCurrent(session)) return;
+    lastError = error instanceof Error ? error : new Error(String(error));
+    status = 'error';
+    levelMenuOpen = false;
+    stopLoop();
+    hud.result('error');
+    options.onError?.(lastError);
+  };
+  const draw = () => {
+    if (current?.hooks && !contextLost && !disposed) {
+      try {
+        current.hooks.beforeRender?.();
+        renderer.render(current.scene, current.camera);
+      } catch (error) { report(error); }
+    }
+  };
+  const advance = (dt) => {
+    if (status !== 'playing') return;
+    elapsed += dt;
+    try { current.hooks?.update?.(dt, elapsed); } catch (error) { report(error); }
+    if (status === 'playing' && current.failure.type === 'time') {
+      current.failure.remaining = Math.max(0, current.failure.remaining - dt);
+      // Absorb floating point residue from fixed simulation substeps.
+      if (current.failure.remaining < 1e-9) current.failure.remaining = 0;
+      hud.resource(current.failure);
+      if (current.failure.remaining === 0) finish(current, 'failed');
+    }
+  };
+  function stopLoop() { cancelAnimationFrame(frame); frame = 0; previousTime = undefined; }
+  const shouldRun = () => !capture && !disposed && !contextLost && !document.hidden && !manuallyPaused && status === 'playing';
+  const tick = (time) => {
+    frame = 0;
+    if (!shouldRun()) return;
+    const dt = previousTime == null ? 0 : Math.min((time - previousTime) / 1000, 0.05);
+    previousTime = time;
+    advance(dt);
+    draw();
+    if (shouldRun()) frame = requestAnimationFrame(tick);
+  };
+  const startLoop = () => { if (!frame && shouldRun()) frame = requestAnimationFrame(tick); };
+  const finish = (session, outcome) => {
+    if (!isCurrent(session) || !['playing', 'paused'].includes(status)) return false;
+    status = outcome;
+    levelMenuOpen = false;
+    stopLoop();
+    hud.result(outcome, session.failure);
+    return true;
+  };
+  const consume = (session, type) => {
+    if (!isCurrent(session) || status !== 'playing' || session.failure.type !== type) return false;
+    session.failure.remaining = Math.max(0, session.failure.remaining - 1);
+    hud.resource(session.failure);
+    if (session.failure.remaining === 0) finish(session, 'failed');
+    return true;
+  };
+  const resize = () => {
+    if (disposed) return;
+    const viewport = window.visualViewport;
+    const fullPage = root === document.body;
+    const bounds = root.getBoundingClientRect();
+    const availableWidth = fullPage ? viewport?.width ?? innerWidth : bounds.width;
+    height = Math.max(1, Math.round(fullPage ? viewport?.height ?? innerHeight : bounds.height));
+    width = Math.max(1, Math.round(Math.min(availableWidth, maxWidth, height * 9 / 16)));
+    if (fullPage) {
+      root.style.height = `${height}px`;
+      root.style.width = `${availableWidth}px`;
+      root.style.top = `${viewport?.offsetTop ?? 0}px`;
+      root.style.left = `${viewport?.offsetLeft ?? 0}px`;
+    }
+    stage.style.width = `${width}px`;
+    renderer.setPixelRatio(captureDpr > 0 && captureDpr <= 4 ? captureDpr : Math.min(window.devicePixelRatio || 1, maxPixelRatio));
+    renderer.setSize(width, height, false);
+    if (current) {
+      if (current.autoResizeCamera && current.camera.isPerspectiveCamera) {
+        current.camera.aspect = width / height;
+        current.camera.updateProjectionMatrix();
+      }
+      try { current.hooks?.resize?.(width, height); draw(); } catch (error) { report(error); }
+    }
+  };
+  const scheduleResize = () => {
+    cancelAnimationFrame(resizeFrame);
+    resizeFrame = requestAnimationFrame(resize);
+  };
+  const cleanup = (session) => {
+    if (!session) return;
+    session.controller.abort();
+    if (session.hooks && !session.hooksDisposed) {
+      session.hooksDisposed = true;
+      try { session.hooks.dispose?.(); } catch (error) { console.error('Level cleanup failed:', error); }
+    }
+    disposeScene(session.scene);
+  };
+  const loadLevel = async (index) => {
+    if (disposed) throw new Error('This game has been disposed.');
+    if (!Number.isInteger(index) || index < 0 || index >= levels.length) throw new RangeError('Level index is out of range.');
+    const version = ++generation;
+    stopLoop();
+    cleanup(current);
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(options.background ?? '#221e4e');
+    scene.add(new THREE.HemisphereLight(0xefe3ff, 0x30245e, 2.5));
+    const light = new THREE.DirectionalLight(0xfff4d8, 3);
+    light.position.set(4, 8, 5);
+    scene.add(light);
+    const camera = new THREE.PerspectiveCamera(40, width / height, 0.1, 200);
+    camera.position.set(5, 6, 9);
+    camera.lookAt(0, 0, 0);
+    const session = { index, scene, camera, failure: { ...failures[index] }, autoResizeCamera: true, controller: new AbortController(), hooks: null };
+    current = session;
+    status = 'loading'; elapsed = 0; lastError = null;
+    levelMenuOpen = false;
+    hud.reset(index, session.failure);
+    const context = {
+      scene, camera, renderer, level: levels[index], index,
+      signal: session.controller.signal,
+      get width() { return width; }, get height() { return height; },
+      get failure() { return Object.freeze({ ...session.failure }); },
+      win: () => finish(session, 'won'),
+      fail: () => finish(session, 'failed'),
+      mistake: () => consume(session, 'hearts'),
+      move: () => consume(session, 'moves'),
+    };
+    try {
+      const hooks = await levels[index].setup(context);
+      session.hooks = hooks ?? {};
+      if (disposed || version !== generation) {
+        cleanup(session);
+        return false;
+      }
+      session.camera = session.hooks.camera ?? camera;
+      session.autoResizeCamera = session.hooks.autoResizeCamera ?? !session.hooks.camera;
+      status = manuallyPaused || levelMenuOpen ? 'paused' : 'playing';
+      resize();
+      startLoop();
+      return true;
+    } catch (error) {
+      if (!isCurrent(session)) { cleanup(session); return false; }
+      report(error, session);
+      cleanup(session);
+      throw error;
+    }
+  };
+  const game = {
+    renderer,
+    get scene() { return current?.scene; },
+    get camera() { return current?.camera; },
+    get state() { return Object.freeze({ status, index: current?.index ?? initial, elapsed, error: lastError,
+      failure: Object.freeze({ ...(current?.failure ?? failures[initial]) }),
+    }); },
+    debug: () => isCurrent(current) ? current.hooks?.debug?.() ?? null : null,
+    loadLevel,
+    restart: () => loadLevel(current?.index ?? initial),
+    next: () => loadLevel(Math.min((current?.index ?? initial) + 1, levels.length - 1)),
+    previous: () => loadLevel(Math.max((current?.index ?? initial) - 1, 0)),
+    win: () => finish(current, 'won'),
+    fail: () => finish(current, 'failed'),
+    mistake: () => consume(current, 'hearts'),
+    move: () => consume(current, 'moves'),
+    playOn() {
+      if (!isCurrent(current) || status !== 'failed' || current.failure.type === 'default') return false;
+      const failure = current.failure;
+      failure.remaining = failure.type === 'hearts' ? failure.initial : failure.remaining + failure.playOnAmount;
+      status = manuallyPaused ? 'paused' : 'playing';
+      hud.resource(failure);
+      hud.hideResult();
+      try { current.hooks?.onPlayOn?.(); } catch (error) { report(error); return false; }
+      draw();
+      startLoop();
+      return true;
+    },
+    pause() { manuallyPaused = true; if (status === 'playing') status = 'paused'; stopLoop(); },
+    resume() { manuallyPaused = false; if (status === 'paused' && !levelMenuOpen) status = 'playing'; startLoop(); },
+    step(seconds = 1 / 60) {
+      if (!Number.isFinite(seconds) || seconds < 0 || seconds > 60) throw new RangeError('step seconds must be between 0 and 60.');
+      if (disposed) throw new Error('This game has been disposed.');
+      const steps = Math.ceil(seconds * 60);
+      for (let i = 0; i < steps; i++) advance(seconds / steps);
+      draw();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true; generation++; status = 'disposed';
+      stopLoop(); cancelAnimationFrame(resizeFrame);
+      lifetime.abort(); observer.disconnect(); cleanup(current); hud.dispose();
+      renderer.dispose(); renderer.forceContextLoss(); stage.remove();
+      root.classList.remove('meshpad-root');
+      for (const [property, value] of Object.entries(originalStyle)) root.style[property] = value;
+      if (window.__MESHPAD__ === game) delete window.__MESHPAD__;
+    },
+  };
+  const originalStyle = Object.fromEntries(['height', 'width', 'top', 'left'].map((key) => [key, root.style[key]]));
+  const observer = new ResizeObserver(scheduleResize);
+  observer.observe(root);
+  for (const event of ['resize', 'orientationchange', 'pageshow']) listen(window, event, scheduleResize, { passive: true });
+  for (const event of ['resize', 'scroll']) if (window.visualViewport) listen(window.visualViewport, event, scheduleResize, { passive: true });
+  listen(document, 'visibilitychange', () => { stopLoop(); startLoop(); });
+  listen(window, 'pagehide', stopLoop);
+  listen(window, 'pageshow', startLoop);
+  for (const event of ['gesturestart', 'gesturechange', 'gestureend', 'contextmenu', 'dragstart']) listen(stage, event, (e) => e.preventDefault(), { passive: false });
+  listen(stage, 'touchmove', (event) => { if (event.touches.length > 1) event.preventDefault(); }, { passive: false });
+  listen(renderer.domElement, 'webglcontextlost', (event) => {
+    event.preventDefault(); contextLost = true; stopLoop();
+  });
+  listen(renderer.domElement, 'webglcontextrestored', () => {
+    contextLost = false; resize(); startLoop();
+  });
+  const raycaster = new THREE.Raycaster();
+  const pointer = new THREE.Vector2();
+  for (const type of ['pointerdown', 'pointermove', 'pointerup', 'pointercancel']) listen(renderer.domElement, type, (event) => {
+    if (status !== 'playing') return;
+    if (type === 'pointerdown') renderer.domElement.setPointerCapture(event.pointerId);
+    const rect = renderer.domElement.getBoundingClientRect();
+    pointer.set((event.clientX - rect.left) / rect.width * 2 - 1, -((event.clientY - rect.top) / rect.height) * 2 + 1);
+    current.camera.updateMatrixWorld(); current.scene.updateMatrixWorld(true);
+    raycaster.setFromCamera(pointer, current.camera);
+    try {
+      current.hooks?.pointer?.({ type, originalEvent: event, point: pointer.clone(), raycaster, hits: (objects = current.scene.children) => raycaster.intersectObjects(objects, true) });
+    } catch (error) { report(error); }
+  });
+  resize();
+  // The capture tool uses the same runtime and setup code as the interactive game.
+  window.__MESHPAD__ = game;
+  // Let the entry module finish initializing classes and constants. Explicit loads
+  // or disposal before this microtask supersede the deferred initial load.
+  game.ready = Promise.resolve().then(() => !disposed && generation === 0 ? loadLevel(initial) : false);
+  game.ready.catch(() => {});
+  return game;
+}