@hypersoniclabs/helix-cli 0.1.7 → 0.1.24-helix3.438

package/dist/visualQa/vehicleProbe.js

@@ -0,0 +1,670 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HIDE_OVERLAYS = exports.INSTALL_VEHICLE_PROBE = void 0;
+// Page-side probe for the vehicle render route. Installed into the test-grounds world frame as `globalThis.__vqaVeh`.
+// Plain JavaScript in a string so nothing the TypeScript compiler emits can leak into the page.
+//
+// What "drawn" means here: the runtime batches a car's static parts into `helix:vehicle-batch:*` BatchedMeshes
+// (engine `vehicleBatchedDraw.ts`). Every original mesh stays in the graph with its real transform and a material
+// clone set `visible = false`; the batch pulls its matrix every render. So a batched part IS drawn, at exactly the
+// pose of its proxy mesh — and the batch's own geometry (all parts packed in their local frames) is never measured.
+exports.INSTALL_VEHICLE_PROBE = `(() => {
+  const G = globalThis;
+  if (G.__vqaVeh) return true;
+  const HW = /(wheel|rim|tyre|tire|brake|caliper|disc|disk|rotor|hub|knuckle|upright|strut|spring|damper|shock|susp|axle|driveshaft|halfshaft|cv_?joint|control_?arm|wishbone|tie_?rod)/i;
+  const BODYISH = /(arch|well|liner|house|fender|guard|steer|tub|light|lamp|pedal|lever)/i;
+  const WHEELISH = /(^|[^a-z])(wheel|rim|tyre|tire)s?([^a-z]|$)/i;
+  const P = {};
+  P.mp = () => G.__assetGym.mp;
+  P.e = () => P.mp().portableVehicles.presentationRows()[0].entity;
+  P.root = () => P.e().object3d;
+  P.batches = () => { const out = []; P.root().traverse((o) => { if (o.isBatchedMesh && Array.isArray(o.instances)) out.push(o); }); return out; };
+  P.proxies = () => { const m = new Map(); for (const b of P.batches()) for (const inst of b.instances) m.set(inst.mesh, inst); return m; };
+  P.chainVisible = (o, root) => { for (let p = o; p; p = p.parent) { if (p.visible === false) return false; if (p === root) return true; } return true; };
+  P.drawn = (o, proxies, root) => {
+    if (!o.isMesh || o.isBatchedMesh || !o.geometry || !o.geometry.attributes || !o.geometry.attributes.position) return false;
+    if (!P.chainVisible(o, root)) return false;
+    const inst = proxies.get(o);
+    if (inst) return inst.visibleIntent !== false;
+    const ms = Array.isArray(o.material) ? o.material : [o.material];
+    return ms.some((m) => m && m.visible !== false && !(m.transparent && (m.opacity ?? 1) < 0.02) && m.colorWrite !== false);
+  };
+  P.inv = () => { const r = P.root(); r.updateMatrixWorld(true); return r.matrixWorld.clone().invert(); };
+  P.V = () => P.root().position.constructor;
+  P.Q = () => P.root().quaternion.constructor;
+  /** Index-referenced vertices of a mesh in BODY frame, appended flat to out. At most ~maxN unique vertices. With outBone
+   *  (skinned meshes), the skeleton index of each vertex's largest skin weight is appended to it, in the same order. */
+  P.meshPoints = (o, inv, maxN, out, outBone) => {
+    const g = o.geometry, pos = g.attributes.position;
+    const M = inv.clone().multiply(o.matrixWorld); const e = M.elements;
+    const idx = g.index ? g.index.array : null;
+    const start = (g.drawRange && g.drawRange.start) || 0;
+    const total = idx ? idx.length : pos.count;
+    const count = Math.min(total - start, Number.isFinite(g.drawRange && g.drawRange.count) ? g.drawRange.count : total);
+    const seen = new Uint8Array(pos.count);
+    const step = Math.max(1, Math.ceil(pos.count / maxN));
+    const skinned = o.isSkinnedMesh && typeof o.getVertexPosition === 'function';
+    const tmp = skinned ? new (P.V())() : null;
+    const si = skinned && outBone ? g.attributes.skinIndex : null, sw = skinned && outBone ? g.attributes.skinWeight : null;
+    let k = 0;
+    for (let i = start; i < start + count; i++) {
+      const vi = idx ? idx[i] : i;
+      if (seen[vi]) continue; seen[vi] = 1;
+      if ((k++ % step) !== 0) continue;
+      let x, y, z;
+      if (skinned) { o.getVertexPosition(vi, tmp); x = tmp.x; y = tmp.y; z = tmp.z; } else { x = pos.getX(vi); y = pos.getY(vi); z = pos.getZ(vi); }
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) continue;
+      out.push(e[0] * x + e[4] * y + e[8] * z + e[12], e[1] * x + e[5] * y + e[9] * z + e[13], e[2] * x + e[6] * y + e[10] * z + e[14]);
+      if (outBone) {
+        let bi = -1, bw = -1;
+        if (si && sw) for (let c = 0; c < 4; c++) { const w = sw.getComponent(vi, c); if (w > bw) { bw = w; bi = si.getComponent(vi, c); } }
+        outBone.push(bi);
+      }
+    }
+    return out;
+  };
+  /** Triangles of a mesh (body frame) whose AABB comes within reach of any hub, appended flat (9 per triangle). */
+  P.meshTris = (o, inv, hubs, reach, out, outMesh, mi) => {
+    const g = o.geometry, pos = g.attributes.position;
+    const M = inv.clone().multiply(o.matrixWorld); const e = M.elements;
+    const idx = g.index ? g.index.array : null;
+    const start = (g.drawRange && g.drawRange.start) || 0;
+    const total = idx ? idx.length : pos.count;
+    const count = Math.min(total - start, Number.isFinite(g.drawRange && g.drawRange.count) ? g.drawRange.count : total);
+    const v = new Float64Array(9);
+    for (let i = start; i + 2 < start + count; i += 3) {
+      for (let k = 0; k < 3; k++) {
+        const vi = idx ? idx[i + k] : i + k;
+        const x = pos.getX(vi), y = pos.getY(vi), z = pos.getZ(vi);
+        v[3 * k] = e[0] * x + e[4] * y + e[8] * z + e[12]; v[3 * k + 1] = e[1] * x + e[5] * y + e[9] * z + e[13]; v[3 * k + 2] = e[2] * x + e[6] * y + e[10] * z + e[14];
+      }
+      let near = false;
+      for (const h of hubs) {
+        let ok = true;
+        for (let a = 0; a < 3 && ok; a++) { const lo = Math.min(v[a], v[3 + a], v[6 + a]), hi = Math.max(v[a], v[3 + a], v[6 + a]); if (hi < h[a] - reach || lo > h[a] + reach) ok = false; }
+        if (ok) { near = true; break; }
+      }
+      if (!near) continue;
+      for (let k = 0; k < 9; k++) out.push(Math.round(v[k] * 10000) / 10000);
+      outMesh.push(mi);
+    }
+  };
+  P.bodyQuat = (o) => { const Q = P.Q(); const rq = P.root().getWorldQuaternion(new Q()).invert(); const q = rq.multiply(o.getWorldQuaternion(new Q())); return [q.x, q.y, q.z, q.w]; };
+  P.bodyPos = (o, inv) => { const p = o.getWorldPosition(new (P.V())()).applyMatrix4(inv || P.inv()); return [p.x, p.y, p.z]; };
+  P.wheelNode = (id, i) => { const ns = P.e().wheelNodes || []; return ns.find((n) => n.name === id) || ns[i] || null; };
+  P.contacts = () => ((P.e().controller.tuning && P.e().controller.tuning.contacts) || []).filter((k) => k.kind === 'wheel');
+  P.axleOf = (node) => { const V = P.V(); const q = P.bodyQuat(node); const Q = P.Q(); const a = new V(1, 0, 0).applyQuaternion(new Q(q[0], q[1], q[2], q[3])); return [a.x, a.y, a.z]; };
+  const R = (v) => Math.round(v * 10000) / 10000;
+  /** Everything the wheel/arch analysis needs, measured on the drawn geometry. */
+  P.pull = () => {
+    const e = P.e(), root = e.object3d, inv = P.inv(), proxies = P.proxies();
+    const st = e.controller.getState();
+    const contacts = P.contacts();
+    const underWheel = new Set();
+    for (const n of e.wheelNodes || []) n.traverse((o) => underWheel.add(o));
+    // the radius each wheel actually rolls on is its axle's v2 tyre (staggered cars differ per axle), else the contact's own:
+    // see vehicleClearance.wheelRollingRadius
+    const v2 = e.controller.tuning && e.controller.tuning.landV2;
+    const tyres = v2 && Array.isArray(v2.tyreByAxle) ? v2.tyreByAxle : null;
+    const wheels = contacts.map((k, i) => {
+      const node = P.wheelNode(k.id, i);
+      const axle = typeof k.axle === 'number' ? k.axle : null;
+      const fb = (st.wheels && st.wheels[i]) || {};
+      const meshes = [], pts = [];
+      if (node) node.traverse((o) => { if (P.drawn(o, proxies, root)) { meshes.push(o.name || (o.parent && o.parent.name) || '(unnamed)'); P.meshPoints(o, inv, 8000, pts); } });
+      return {
+        id: k.id, node: node ? node.name : null, mount: k.position, restLength: k.suspension ? k.suspension.restLength : null, travel: k.suspension ? k.suspension.travel : null,
+        radius: k.radius, axle, steered: k.steered, powered: k.powered, compression: fb.compression ?? null, grounded: fb.grounded ?? null,
+        steerAngleRad: fb.steerAngleRad ?? null, contactPoint: fb.contactPoint ? [fb.contactPoint.x, fb.contactPoint.y, fb.contactPoint.z] : null,
+        axleNode: node ? P.axleOf(node) : null, nodePos: node ? P.bodyPos(node, inv) : null,
+        meshes, points: pts.map(R),
+      };
+    });
+    const hubs = wheels.map((w) => w.nodePos).filter(Boolean);
+    const maxHubY = hubs.length ? Math.max(...hubs.map((h) => h[1])) : 0;
+    const names = [], bpts = [], bmesh = [], strays = [], excluded = [], tris = [], triMesh = [];
+    let bodyMeshes = 0, bodyVerts = 0;
+    root.traverse((o) => {
+      if (underWheel.has(o) || !P.drawn(o, proxies, root)) return;
+      const nm = o.name || (o.parent && o.parent.name) || '(unnamed)';
+      if (HW.test(nm) && !BODYISH.test(nm)) {
+        const local = []; P.meshPoints(o, inv, 2000, local);
+        let cx = 0, cy = 0, cz = 0; const n = local.length / 3;
+        for (let j = 0; j < local.length; j += 3) { cx += local[j]; cy += local[j + 1]; cz += local[j + 2]; }
+        const c = n ? [cx / n, cy / n, cz / n] : null;
+        if (WHEELISH.test(nm)) strays.push({ mesh: nm, centre: c && c.map(R) });
+        excluded.push(nm);
+        return;
+      }
+      const local = []; P.meshPoints(o, inv, 200000, local);
+      const mi = names.length; names.push(nm); bodyMeshes++;
+      P.meshTris(o, inv, hubs, 1.0, tris, triMesh, mi);
+      for (let j = 0; j < local.length; j += 3) {
+        const x = local[j], y = local[j + 1], z = local[j + 2];
+        bodyVerts++;
+        let keep = y < maxHubY;
+        if (!keep) for (const h of hubs) { if (Math.hypot(x - h[0], y - h[1], z - h[2]) < 1.0) { keep = true; break; } }
+        if (!keep) continue;
+        bpts.push(R(x), R(y), R(z)); bmesh.push(mi);
+      }
+    });
+    return { wheels, tyreByAxle: tyres ? tyres.map((t) => ({ radius: t && typeof t.radius === 'number' ? t.radius : null })) : null, body: { names, points: bpts, mesh: bmesh }, bodyTris: { names, tris, mesh: triMesh }, strays, excludedHardware: [...new Set(excluded)].slice(0, 40), bodyMeshes, bodyVerts,
+      batches: P.batches().map((b) => ({ name: b.name, instances: b.instances.length })), proxies: proxies.size,
+      state: { speed: st.speed, forwardSpeed: st.forwardSpeed, grounded: st.grounded, position: [st.position.x, st.position.y, st.position.z] } };
+  };
+  /** Suspension compression per wheel, sampled every animation frame for ms (the car rocks for seconds after boarding). */
+  P.compressionWindow = (ms) => new Promise((resolve) => {
+    const e = P.e(); const out = P.contacts().map(() => []); const t0 = performance.now();
+    const tick = () => {
+      try { const st = e.controller.getState(); (st.wheels || []).forEach((w, i) => { if (out[i] && Number.isFinite(w.compression)) out[i].push(w.compression); }); } catch (err) { /* keep sampling */ }
+      if (performance.now() - t0 < ms) requestAnimationFrame(tick); else resolve(out);
+    };
+    requestAnimationFrame(tick);
+  });
+  /** Body-frame AABB of the drawn car (geometry bounding-box corners, so slightly generous). */
+  P.bounds = () => {
+    const root = P.root(), inv = P.inv(), proxies = P.proxies(), V = P.V();
+    const mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity]; const c = new V();
+    root.traverse((o) => {
+      if (!P.drawn(o, proxies, root)) return;
+      if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
+      const b = o.geometry.boundingBox; if (!b) return;
+      const M = inv.clone().multiply(o.matrixWorld);
+      for (let i = 0; i < 8; i++) {
+        c.set(i & 1 ? b.max.x : b.min.x, i & 2 ? b.max.y : b.min.y, i & 4 ? b.max.z : b.min.z).applyMatrix4(M);
+        mn[0] = Math.min(mn[0], c.x); mn[1] = Math.min(mn[1], c.y); mn[2] = Math.min(mn[2], c.z);
+        mx[0] = Math.max(mx[0], c.x); mx[1] = Math.max(mx[1], c.y); mx[2] = Math.max(mx[2], c.z);
+      }
+    });
+    return { min: mn.map(R), max: mx.map(R) };
+  };
+  /** Body-frame AABB of named nodes' drawn meshes. */
+  P.nodeBox = (names) => {
+    const root = P.root(), inv = P.inv(), proxies = P.proxies();
+    const pts = [];
+    for (const n of names) { const o = root.getObjectByName(n); if (!o) continue; o.traverse((m) => { if (P.drawn(m, proxies, root)) P.meshPoints(m, inv, 3000, pts); }); }
+    if (!pts.length) return null;
+    const mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity];
+    for (let j = 0; j < pts.length; j += 3) for (let a = 0; a < 3; a++) { mn[a] = Math.min(mn[a], pts[j + a]); mx[a] = Math.max(mx[a], pts[j + a]); }
+    return { min: mn.map(R), max: mx.map(R) };
+  };
+  P.pose = (names) => {
+    const root = P.root(), inv = P.inv(); const out = {};
+    for (const n of names) { const o = root.getObjectByName(n); out[n] = o ? { q: P.bodyQuat(o), p: P.bodyPos(o, inv) } : null; }
+    return out;
+  };
+  /** Pose of node b in node a's frame (rigidity check). */
+  P.rel = (a, b) => {
+    const root = P.root(); const A = root.getObjectByName(a), B = root.getObjectByName(b); if (!A || !B) return null;
+    root.updateMatrixWorld(true);
+    const V = P.V(), Q = P.Q();
+    const p = A.worldToLocal(B.getWorldPosition(new V()));
+    const rel = A.getWorldQuaternion(new Q()).invert().multiply(B.getWorldQuaternion(new Q()));
+    return { p: [p.x, p.y, p.z], q: [rel.x, rel.y, rel.z, rel.w] };
+  };
+  P.durable = () => { try { const v = P.mp().portableVehicleEvidence().vehicles[0]; return v ? (v.durableState || {}) : {}; } catch (err) { return {}; } };
+  P.steering = () => {
+    const e = P.e(), root = e.object3d; const st = e.controller.getState();
+    const rim = (e.interior && (e.interior.steeringRim || e.interior.steering)) || root.getObjectByName('steering_rim') || root.getObjectByName('steering');
+    const contacts = P.contacts();
+    return {
+      rimNode: rim ? rim.name : null, rimQ: rim ? P.bodyQuat(rim) : null, rimAngleRad: e.interior ? e.interior.rimAngleRad ?? null : null,
+      steerInput: e.controller.input ? e.controller.input.steer : null, stateSteerRad: st.steerAngleRad,
+      wheels: contacts.map((k, i) => { const n = P.wheelNode(k.id, i); return { id: k.id, steered: k.steered, axle: n ? P.axleOf(n) : null, physicsSteerRad: st.wheels && st.wheels[i] ? st.wheels[i].steerAngleRad : null }; }),
+    };
+  };
+  /**
+   * Sample the drawn wheels' rotation about their own axle every animation frame for ms. With a room guard
+   * ({ origin: [x, z], dir: [x, z], limitM, decel }) sampling ends early as soon as the car, braking at decel from now, would
+   * pass limitM along dir from origin; it then resolves { samples, stoppedForRoom } so the caller brakes at once.
+   */
+  P.sampleSpin = (ms, guard) => new Promise((resolve) => {
+    const e = P.e(), root = e.object3d, proxies = P.proxies(), V = P.V();
+    const contacts = P.contacts();
+    let stoppedForRoom = false;
+    const wheels = contacts.map((k, i) => {
+      const node = P.wheelNode(k.id, i); let mesh = null;
+      if (node) node.traverse((o) => { if (!mesh && P.drawn(o, proxies, root)) mesh = o; });
+      return { node, mesh: mesh || node };
+    });
+    const qOf = (o) => { const q = P.bodyQuat(o); return new (P.Q())(q[0], q[1], q[2], q[3]); };
+    // reference axis: the mesh-local axis most perpendicular to the axle, chosen once
+    const refs = wheels.map((w) => {
+      if (!w.mesh) return null;
+      const a = new V(...P.axleOf(w.node)); const q = qOf(w.mesh);
+      const cands = [new V(1, 0, 0), new V(0, 1, 0), new V(0, 0, 1)];
+      let best = 0, bd = Infinity; cands.forEach((c, j) => { const d = Math.abs(c.clone().applyQuaternion(q).dot(a)); if (d < bd) { bd = d; best = j; } });
+      return cands[best];
+    });
+    const samples = [];
+    const t0 = performance.now();
+    const tick = () => {
+      try {
+        const st = e.controller.getState(); const wp = root.getWorldPosition(new V());
+        const ang = wheels.map((w, i) => {
+          if (!w.mesh || !refs[i]) return NaN;
+          let a = new V(...P.axleOf(w.node)); if (a.x < 0) a = a.multiplyScalar(-1);
+          let up = new V(0, 1, 0).sub(a.clone().multiplyScalar(a.y)).normalize();
+          const r = refs[i].clone().applyQuaternion(qOf(w.mesh));
+          r.sub(a.clone().multiplyScalar(r.dot(a)));
+          return Math.atan2(up.clone().cross(r).dot(a), up.dot(r));
+        });
+        samples.push({ t: performance.now(), x: wp.x, z: wp.z, forwardSpeed: st.forwardSpeed, ang });
+        if (guard) {
+          const along = (wp.x - guard.origin[0]) * guard.dir[0] + (wp.z - guard.origin[1]) * guard.dir[1];
+          const v = Math.max(0, st.forwardSpeed);
+          if (along + v * 0.25 + (v * v) / (2 * guard.decel) >= guard.limitM) stoppedForRoom = true;
+        }
+      } catch (err) { /* keep sampling */ }
+      if (performance.now() - t0 < ms && !stoppedForRoom) requestAnimationFrame(tick); else resolve(guard ? { samples, stoppedForRoom } : samples);
+    };
+    requestAnimationFrame(tick);
+  });
+  /** Pin the render camera to a body-frame pose, re-applied every frame so the follow cam cannot fight it. */
+  /**
+   * Project body-frame points (flat xyz) through the live camera: NDC per point, and the canvas's client rect in this
+   * frame, so an annotation can be drawn over the captured image exactly where the geometry is.
+   */
+  P.project = (flat) => {
+    const cam = P.camera(); const root = P.root(); if (!cam) return null;
+    root.updateMatrixWorld(true); cam.updateMatrixWorld(true);
+    if (cam.matrixWorldInverse) cam.matrixWorldInverse.copy(cam.matrixWorld).invert();
+    const V = P.V(); const v = new V(); const out = [];
+    for (let i = 0; i < flat.length; i += 3) { v.set(flat[i], flat[i + 1], flat[i + 2]).applyMatrix4(root.matrixWorld).project(cam); out.push(v.x, v.y, v.z); }
+    let best = null, area = 0;
+    for (const c of document.querySelectorAll('canvas')) { const r = c.getBoundingClientRect(); if (r.width * r.height > area) { area = r.width * r.height; best = r; } }
+    return { ndc: out, rect: best ? { left: best.left, top: best.top, width: best.width, height: best.height } : null };
+  };
+  P.camera = () => { try { return P.mp().local.services.camera.camera; } catch (err) { return G.__vqa && G.__vqa.main; } };
+  P.setCam = (c) => {
+    const cam = P.camera(); if (!cam) return false;
+    if (!cam.__vqaPinned) {
+      const orig = cam.updateMatrixWorld.bind(cam);
+      cam.updateMatrixWorld = function (force) {
+        const o = G.__vqaCam;
+        if (o) {
+          const r = P.root(); const V = P.V();
+          this.position.copy(r.localToWorld(new V(...o.pos)));
+          this.up.set(0, 1, 0);
+          this.lookAt(r.localToWorld(new V(...o.target)));
+          if (o.fov && this.fov !== o.fov) { this.fov = o.fov; this.updateProjectionMatrix(); }
+          if (o.near && this.near !== o.near) { this.near = o.near; this.updateProjectionMatrix(); }
+        }
+        return orig(force);
+      };
+      cam.__vqaPinned = { fov: cam.fov, near: cam.near };
+    }
+    G.__vqaCam = c; return true;
+  };
+  P.clearCam = () => { G.__vqaCam = null; const cam = P.camera(); if (cam && cam.__vqaPinned) { cam.fov = cam.__vqaPinned.fov; cam.near = cam.__vqaPinned.near; cam.updateProjectionMatrix(); } return true; };
+  /** Scene stats over the drawn car: batched proxies get their real material back for the (synchronous) count. */
+  P.stats = () => {
+    const swapped = [];
+    for (const b of P.batches()) for (const inst of b.instances) { if (inst.mesh.material === inst.hiddenMaterial && inst.originalMaterial) { swapped.push(inst); inst.mesh.material = inst.originalMaterial; } }
+    try { return G.__vqaStats(P.root(), { exclude: (o) => !!o.isBatchedMesh }); }
+    finally { for (const inst of swapped) inst.mesh.material = inst.hiddenMaterial; }
+  };
+  // ---------------------------------------------------------------------------------------------------- seated occupant
+  P.isUnder = (o, anc) => { for (let p = o; p; p = p.parent) if (p === anc) return true; return false; };
+  /** Triangles (body frame, 9 per triangle) of one mesh whose AABB overlaps the box, appended flat. */
+  P.meshTrisInBox = (o, inv, box, out, outMesh, mi) => {
+    const g = o.geometry, pos = g.attributes.position;
+    const M = inv.clone().multiply(o.matrixWorld); const e = M.elements;
+    const idx = g.index ? g.index.array : null;
+    const start = (g.drawRange && g.drawRange.start) || 0;
+    const total = idx ? idx.length : pos.count;
+    const count = Math.min(total - start, Number.isFinite(g.drawRange && g.drawRange.count) ? g.drawRange.count : total);
+    const v = new Float64Array(9);
+    // a mirrored node (negative determinant) flips the winding: swap two corners so the triangle's normal stays outward
+    const det = e[0] * (e[5] * e[10] - e[6] * e[9]) - e[4] * (e[1] * e[10] - e[2] * e[9]) + e[8] * (e[1] * e[6] - e[2] * e[5]);
+    const order = det < 0 ? [0, 2, 1] : [0, 1, 2];
+    for (let i = start; i + 2 < start + count; i += 3) {
+      for (let k = 0; k < 3; k++) {
+        const vi = idx ? idx[i + order[k]] : i + order[k];
+        const x = pos.getX(vi), y = pos.getY(vi), z = pos.getZ(vi);
+        v[3 * k] = e[0] * x + e[4] * y + e[8] * z + e[12]; v[3 * k + 1] = e[1] * x + e[5] * y + e[9] * z + e[13]; v[3 * k + 2] = e[2] * x + e[6] * y + e[10] * z + e[14];
+      }
+      let ok = true;
+      for (let a = 0; a < 3 && ok; a++) { const lo = Math.min(v[a], v[3 + a], v[6 + a]), hi = Math.max(v[a], v[3 + a], v[6 + a]); if (hi < box.min[a] || lo > box.max[a]) ok = false; }
+      if (!ok) continue;
+      for (let k = 0; k < 9; k++) out.push(Math.round(v[k] * 10000) / 10000);
+      outMesh.push(mi);
+    }
+  };
+  /**
+   * The LOCAL occupant: every bone (body frame) and the vertices of every drawn skinned mesh on it (body, hair, hats...),
+   * the steering wheel's vertices, and the car's own drawn triangles in a box around the pelvis. The car's triangles never
+   * include the occupant (skinned meshes, anything under the character model) or the wheels.
+   */
+  P.occupantPull = () => {
+    const mp = P.mp(); const local = mp.local; const model = local && local.model; if (!model) return null;
+    const e = P.e(), root = e.object3d, inv = P.inv(), proxies = P.proxies();
+    root.updateMatrixWorld(true); model.updateMatrixWorld(true);
+    const bones = {}; const boneParents = {}; const skinned = [];
+    model.traverse((o) => { if (o.isBone) { const p = P.bodyPos(o, inv); bones[o.name] = p.map(R); boneParents[o.name] = o.parent && o.parent.isBone ? o.parent.name : null; } if (o.isSkinnedMesh && P.chainVisible(o, model)) skinned.push(o); });
+    const points = []; const pointBone = []; const boneNames = Object.keys(bones); const boneIx = new Map(boneNames.map((n, i) => [n, i]));
+    for (const m of skinned) {
+      const tmp = []; const tb = [];
+      P.meshPoints(m, inv, 30000, tmp, tb);
+      for (let i = 0; i < tmp.length; i++) points.push(R(tmp[i]));
+      // the bone with the largest skin weight per vertex (vehiclePenetration measures each vertex against its own bone)
+      const sb = (m.skeleton && m.skeleton.bones) || [];
+      for (let i = 0; i < tb.length; i++) { const b = sb[tb[i]]; const k = b ? boneIx.get(b.name) : undefined; pointBone.push(k === undefined ? -1 : k); }
+    }
+    const pel = bones.pelvis || bones.hips || Object.values(bones)[0];
+    const box = { min: [pel[0] - 0.8, pel[1] - 0.9, pel[2] - 0.95], max: [pel[0] + 0.8, pel[1] + 1.1, pel[2] + 0.95] };
+    const underWheel = new Set(); for (const n of e.wheelNodes || []) n.traverse((o) => underWheel.add(o));
+    const names = [], tris = [], mesh = [], meshInfo = [];
+    root.traverse((o) => {
+      if (underWheel.has(o) || o.isSkinnedMesh || !P.drawn(o, proxies, root) || P.isUnder(o, model)) return;
+      const mi = names.length; names.push(o.name || (o.parent && o.parent.name) || '(unnamed)');
+      const before = tris.length;
+      P.meshTrisInBox(o, inv, box, tris, mesh, mi);
+      if (tris.length > before) {
+        const inst = proxies.get(o); const m0 = (inst && inst.originalMaterial) || (Array.isArray(o.material) ? o.material[0] : o.material);
+        meshInfo.push({ name: names[mi], batched: !!inst, color: m0 && m0.color ? m0.color.getHexString() : null, opacity: m0 ? m0.opacity : null, transparent: m0 ? !!m0.transparent : null, side: m0 ? m0.side : null, colorWrite: m0 ? m0.colorWrite : null, tris: (tris.length - before) / 9 });
+      }
+    });
+    let rim = null;
+    const rimNode = (e.interior && (e.interior.steeringRim || e.interior.steering)) || root.getObjectByName('steering_rim') || root.getObjectByName('steering');
+    if (rimNode) { const pts = []; rimNode.traverse((m) => { if (m.isMesh && !m.isSkinnedMesh && m.geometry && m.geometry.attributes && m.geometry.attributes.position) P.meshPoints(m, inv, 3000, pts); }); rim = pts.map(R); }
+    let residual = null; try { const l = mp.seatEvidence && mp.seatEvidence().local; residual = l && l.seated ? l.seated.seatResidualM : null; } catch (err) { /* keep null */ }
+    return { bones, boneParents, boneNames, points, pointBone, rim, cabin: { tris, mesh, names }, seatResidualM: residual, skinned: skinned.map((m) => m.name || '(unnamed)'), meshInfo, rimNode: rimNode ? rimNode.name : null };
+  };
+  /** Body-frame position of a seat: its named node when the model has one, else the cabin's own H-point. */
+  P.seatPos = (id) => {
+    const root = P.root(); root.updateMatrixWorld(true); let o = null;
+    root.traverse((x) => { if (!o && x.name === id && !x.isMesh) o = x; });
+    if (o) return P.bodyPos(o);
+    try { const s = P.e().interior.cabin.seats.find((x) => x.id === id); return s ? [s.hipPoint[0], s.hipPoint[1], s.hipPoint[2]] : null; } catch (err) { return null; }
+  };
+  /** Hide (or restore) named nodes, for a labelled cutaway frame. The vehicle batch reads visibility as the AND of the ancestors up to the root. */
+  /**
+   * Evidence cutaway: hide every drawn mesh of the car except those named (by the same name the occupant pull records),
+   * so only the occupant and the surface it clashes with are drawn. P.unisolate() puts every flag back exactly.
+   */
+  P.isolate = (keep) => {
+    P.unisolate();
+    const mp = P.mp(); const model = mp.local && mp.local.model; const root = P.root(); const proxies = P.proxies();
+    const ks = new Set(keep || []); const hidden = [];
+    root.traverse((o) => {
+      if (!o.isMesh || (model && P.isUnder(o, model)) || !P.drawn(o, proxies, root)) return;
+      const nm = o.name || (o.parent && o.parent.name) || '(unnamed)';
+      if (ks.has(nm)) return;
+      hidden.push([o, o.visible]); o.visible = false;
+    });
+    P.__isolated = hidden; return hidden.length;
+  };
+  P.unisolate = () => { const h = P.__isolated || []; for (const [o, v] of h) o.visible = v; P.__isolated = null; return h.length; };
+  P.setHidden = (names, hidden) => { const root = P.root(); let n = 0; for (const nm of names) { const o = root.getObjectByName(nm); if (o) { o.visible = !hidden; n++; } } return n; };
+  /** The engine's own cabin-fit self-report (what it BELIEVES the occupant fit is), for comparison with what is drawn. */
+  // ---------------------------------------------------------------------------------------------------- scenery
+  /** The local player's character model (hidden for the appearance poses, never for an occupant frame). */
+  P.avatar = () => { try { return P.mp().local.model || null; } catch (err) { return null; } };
+  P.sceneRoot = () => { let s = P.root(); while (s.parent) s = s.parent; return s; };
+  /** Is o part of the car or of a character (the local one, or anyone skinned)? Those are never scenery. */
+  P.notScenery = (o, root, avatar) => P.isUnder(o, root) || (avatar && P.isUnder(o, avatar)) || o.isSkinnedMesh;
+  /**
+   * WORLD-frame boxes of every visible scenery mesh within radius of the car (the walls, kerbs and props of the test
+   * grounds), plus the car's body->world matrix, so the clearance and occlusion maths can run outside the page.
+   */
+  P.sceneBoxes = (radius) => {
+    const root = P.root(), scene = P.sceneRoot(), avatar = P.avatar(), V = P.V();
+    root.updateMatrixWorld(true);
+    const at = root.getWorldPosition(new V()); const out = []; const c = new V();
+    scene.traverse((o) => {
+      if (!o.isMesh || !o.geometry || !o.geometry.attributes || !o.geometry.attributes.position) return;
+      if (P.notScenery(o, root, avatar)) return;
+      for (let p = o; p; p = p.parent) if (p.visible === false) return;
+      // effects (particles, glows, soft quads) write no depth and stop nothing: not scenery
+      const ms = Array.isArray(o.material) ? o.material : [o.material];
+      if (ms.every((m) => !m || m.depthWrite === false || m.visible === false || (m.transparent && (m.opacity ?? 1) < 0.35))) return;
+      if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
+      const b = o.geometry.boundingBox; if (!b || b.isEmpty()) return;
+      const mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity];
+      for (let i = 0; i < 8; i++) {
+        c.set(i & 1 ? b.max.x : b.min.x, i & 2 ? b.max.y : b.min.y, i & 4 ? b.max.z : b.min.z).applyMatrix4(o.matrixWorld);
+        mn[0] = Math.min(mn[0], c.x); mn[1] = Math.min(mn[1], c.y); mn[2] = Math.min(mn[2], c.z);
+        mx[0] = Math.max(mx[0], c.x); mx[1] = Math.max(mx[1], c.y); mx[2] = Math.max(mx[2], c.z);
+      }
+      const dx = Math.max(mn[0] - at.x, 0, at.x - mx[0]), dz = Math.max(mn[2] - at.z, 0, at.z - mx[2]);
+      if (Math.hypot(dx, dz) > (radius || 60)) return;
+      out.push({ id: o.uuid, name: o.name || (o.parent && o.parent.name) || '(unnamed)', min: mn.map(R), max: mx.map(R) });
+    });
+    return { boxes: out, bodyToWorld: Array.from(root.matrixWorld.elements) };
+  };
+  /** Hide (true) or restore (false) scenery meshes by uuid, for one frame; restore puts back exactly what was changed. */
+  P.hideScenery = (ids, on) => {
+    if (!on) { const h = P.__sceneHidden || []; for (const [o, v] of h) o.visible = v; P.__sceneHidden = null; return h.length; }
+    const want = new Set(ids || []); const h = P.__sceneHidden || []; const scene = P.sceneRoot();
+    scene.traverse((o) => { if (want.has(o.uuid) && o.visible !== false) { h.push([o, o.visible]); o.visible = false; } });
+    P.__sceneHidden = h; return h.length;
+  };
+  /**
+   * Appearance poses: everything but the car is hidden (scenery AND the player's own avatar) over a plain neutral
+   * backdrop, lit by the world's own lights/environment. P.backdrop(false) puts every flag and the background back.
+   */
+  /**
+   * Appearance poses: every lamp OFF and no local light, so nothing blooms over the nose (F40 round 1: a white blob over
+   * pose.front and pose.top; measured, it was the test grounds' stage point lights on glossy paint, not the lamps).
+   * Zeroes the emissive of every material the car draws with (its batch materials and each batched part's own material
+   * too), hides additive-blended coronas under the car, and zeroes every spot/point/area light in the scene (the
+   * runtime's headlamp beams and the world's practical lamps); the sun/sky and the environment stay. The engine never
+   * rewrites emissive per frame, so this holds for the frames. P.lightsOff(false) restores every value exactly.
+   */
+  P.lightsOff = (on) => {
+    if (!on) {
+      const st = P.__lightsOff; if (!st) return null;
+      for (const [m, i, c] of st.mats) { m.emissiveIntensity = i; if (c && m.emissive) m.emissive.copy(c); m.needsUpdate = true; }
+      for (const [o, v] of st.hidden) o.visible = v;
+      for (const [l, i] of st.lights) l.intensity = i;
+      P.__lightsOff = null; return { materials: st.mats.length, coronas: st.hidden.length, lights: st.lights.length };
+    }
+    if (P.__lightsOff) return null;
+    const root = P.root(), scene = P.sceneRoot(), V = P.V();
+    const mats = [], hidden = [], lights = []; const seen = new Set();
+    const take = (m) => {
+      if (!m || seen.has(m)) return; seen.add(m);
+      if (typeof m.emissiveIntensity !== 'number' && !m.emissive) return;
+      const black = m.emissive ? m.emissive.clone() : null;
+      mats.push([m, m.emissiveIntensity, black]);
+      if (typeof m.emissiveIntensity === 'number') m.emissiveIntensity = 0;
+      if (m.emissive) m.emissive.setRGB(0, 0, 0);
+      m.needsUpdate = true;
+    };
+    const proxies = P.proxies();
+    root.traverse((o) => {
+      const ms = o.material ? (Array.isArray(o.material) ? o.material : [o.material]) : [];
+      for (const m of ms) take(m);
+      const inst = proxies.get(o); if (inst) { take(inst.originalMaterial); take(inst.hiddenMaterial); }
+      if ((o.isMesh || o.isPoints || o.isSprite) && o.visible !== false && ms.some((m) => m && m.blending === 2)) { hidden.push([o, o.visible]); o.visible = false; }
+    });
+    // every LOCAL light off too (spot and point: the car's beams, and the world's own practical lamps; the test grounds'
+    // stage lights put a white hotspot on a glossy nose): the poses are lit by the sun/sky and the environment only
+    scene.traverse((o) => {
+      if (!(o.isSpotLight || o.isPointLight || o.isRectAreaLight) || !(o.intensity > 0)) return;
+      lights.push([o, o.intensity]); o.intensity = 0;
+    });
+    P.__lightsOff = { mats, hidden, lights };
+    return { materials: mats.length, coronas: hidden.length, lights: lights.length };
+  };
+  P.backdrop = (on, hex) => {
+    const scene = P.sceneRoot();
+    if (!on) {
+      const st = P.__backdrop; if (!st) return 0;
+      for (const [o, v] of st.hidden) o.visible = v;
+      scene.background = st.background; P.__backdrop = null; return st.hidden.length;
+    }
+    if (P.__backdrop) return P.__backdrop.hidden.length;
+    const root = P.root(), avatar = P.avatar(); const hidden = [];
+    scene.traverse((o) => {
+      if (!(o.isMesh || o.isSprite || o.isPoints || o.isLine) || o.visible === false) return;
+      if (P.isUnder(o, root) && !(avatar && P.isUnder(o, avatar))) return;
+      hidden.push([o, o.visible]); o.visible = false;
+    });
+    if (avatar && avatar.visible !== false) { hidden.push([avatar, avatar.visible]); avatar.visible = false; }
+    const st = { hidden, background: scene.background };
+    let Color = null;
+    root.traverse((o) => { if (!Color && o.material && !Array.isArray(o.material) && o.material.color) Color = o.material.color.constructor; });
+    if (Color) scene.background = new Color(hex || 0x8c8f94);
+    P.__backdrop = st; return hidden.length;
+  };
+  /**
+   * Daylight paint sample: with the backdrop already on (every non-car mesh hidden over a flat key colour), hide every
+   * drawn car mesh whose material is not body paint, so the only pixels left that are not the key colour are paint. The
+   * world's lights and the lamps are NOT touched: this is the paint exactly as the Try Now frame lights it, hotspots
+   * and all (the appearance poses turn the local lights off, which is why they never showed the bonnet glare).
+   * A body-paint mesh is one whose material name carries "paint" (the <node>__vehicle-paint-solid|metallic family
+   * suffix). Batched parts follow their proxy mesh's visible flag on the next sync. P.paintOnly(false) restores.
+   * Returns the paint materials as the runtime really draws them (colour, roughness, clearcoat...).
+   */
+  /** The lighting rig the frame is drawn with: scene environment/background/fog, every light, and what the gym exposes of the renderer. */
+  P.lighting = () => {
+    const scene = P.sceneRoot(), out = { background: null, environment: !!scene.environment, environmentIntensity: scene.environmentIntensity ?? null, backgroundIntensity: scene.backgroundIntensity ?? null, fog: scene.fog ? scene.fog.type || scene.fog.constructor.name : null, lights: [], gym: Object.keys(G.__assetGym || {}).slice(0, 40), renderer: null };
+    const bg = scene.background; out.background = bg ? (bg.isColor ? '#' + bg.getHexString() : (bg.constructor && bg.constructor.name)) : null;
+    scene.traverse((o) => { if (o.isLight) out.lights.push({ type: o.type, name: o.name || null, intensity: o.intensity, color: o.color ? '#' + o.color.getHexString() : null, visible: o.visible }); });
+    const r = (G.__assetGym && (G.__assetGym.renderer || (G.__assetGym.mp && G.__assetGym.mp.renderer))) || G.__vqaRenderer || null;
+    if (r) out.renderer = { toneMapping: r.toneMapping, exposure: r.toneMappingExposure, outputColorSpace: r.outputColorSpace, type: r.constructor && r.constructor.name };
+    return out;
+  };
+  /** With paintOnly on: show (true) or hide (false) the paint meshes too, for the empty-scene reference frame the mask is taken against. */
+  P.paintShow = (v) => { for (const o of P.__paintMeshes || []) o.visible = v; return (P.__paintMeshes || []).length; };
+  P.paintOnly = (on) => {
+    if (!on) { const h = P.__paintHidden || []; for (const [o, v] of h) o.visible = v; for (const o of P.__paintMeshes || []) o.visible = true; P.__paintHidden = null; P.__paintMeshes = null; return h.length; }
+    if (P.__paintHidden) return null;
+    const root = P.root(), proxies = P.proxies(); const hidden = []; const mats = new Map(); const paintMeshes = [];
+    const avatar = P.avatar();
+    root.traverse((o) => {
+      if (!o.isMesh || o.isBatchedMesh || (avatar && P.isUnder(o, avatar))) return;
+      const inst = proxies.get(o);
+      const src = inst ? inst.originalMaterial : o.material;
+      const ms = (Array.isArray(src) ? src : [src]).filter(Boolean);
+      const paint = ms.filter((m) => /paint/i.test(m.name || ''));
+      if (paint.length) { for (const m of paint) if (!mats.has(m)) mats.set(m, 0); paintMeshes.push(o); return; }
+      if (o.visible !== false) { hidden.push([o, o.visible]); o.visible = false; }
+    });
+    P.__paintHidden = hidden; P.__paintMeshes = paintMeshes;
+    const hex = (c) => c && c.isColor ? '#' + c.getHexString() : null;
+    const R3 = (v) => typeof v === 'number' ? Math.round(v * 1000) / 1000 : null;
+    return [...mats.keys()].map((m) => ({
+      name: m.name, type: m.type, baseColorLinear: m.color ? [R3(m.color.r), R3(m.color.g), R3(m.color.b)] : null, baseColorHex: hex(m.color),
+      metalness: R3(m.metalness), roughness: R3(m.roughness), clearcoat: R3(m.clearcoat), clearcoatRoughness: R3(m.clearcoatRoughness),
+      ior: R3(m.ior), specularIntensity: R3(m.specularIntensity), envMapIntensity: R3(m.envMapIntensity), emissive: hex(m.emissive), emissiveIntensity: R3(m.emissiveIntensity),
+      hasMap: !!m.map,
+    }));
+  };
+  /**
+   * Seat placement as authored vs as the runtime seats it: the seat's own GLB node (the authored H-point, body frame)
+   * and the cabin seat the occupant is posed on after the runtime's cabin fit.
+   */
+  P.seatFit = (id) => {
+    const root = P.root(); root.updateMatrixWorld(true); let node = null;
+    root.traverse((x) => { if (!node && x.name === id && !x.isMesh) node = x; });
+    let cabin = null;
+    try { const s = P.e().interior.cabin.seats.find((x) => x.id === id); if (s && s.hipPoint) cabin = [s.hipPoint[0], s.hipPoint[1], s.hipPoint[2]].map(R); } catch (err) { /* none */ }
+    return { node: node ? P.bodyPos(node).map(R) : null, cabin };
+  };
+  P.cabinFit = () => { try { const f = P.e().cabinFit; return f ? JSON.parse(JSON.stringify(f.report ?? f)) : null; } catch (err) { return null; } };
+  /**
+   * GRIP / STILLNESS window (vehicleGrip.ts): the local occupant's arm, hand and finger bones on each of the next n
+   * animation frames, read after the engine posed them. Every finger joint is also given in its own HAND's frame
+   * (rotation only, metres), so a hand that travels with the steering wheel does not read as its fingers moving. At the
+   * end: the steering wheel's vertices (body frame, at most ~1500) and its rotation, and the controller's steer input.
+   */
+  P.occupantFrames = (n, stride) => new Promise((resolve) => {
+    const every = Math.max(1, stride || 1); let tick = 0;
+    let model = null; try { model = P.mp().local.model; } catch (err) { model = null; }
+    if (!model) { resolve(null); return; }
+    const ARM = /^(clavicle|upperarm|lowerarm|forearm|hand|thumb|index|middle|ring|pinky|pink)(_\\d+)?(_twist_?\\d*)?[_.](l|r)$/i;
+    const FINGER = /^(thumb|index|middle|ring|pinky|pink)(_\\d+)?[_.](l|r)$/i;
+    const bones = []; model.traverse((o) => { if (o.isBone && ARM.test(o.name)) bones.push(o); });
+    const hands = {}; for (const b of bones) { const m = /^hand[_.](l|r)$/i.exec(b.name); if (m) hands[m[1].toLowerCase()] = b; }
+    const V = P.V(), Q = P.Q(); const frames = []; const t0 = performance.now();
+    const step = () => {
+      if ((tick++ % every) !== 0) { requestAnimationFrame(step); return; }
+      const inv = P.inv(); const body = {}; const inHand = {}; const localQ = {};
+      for (const b of bones) { body[b.name] = P.bodyPos(b, inv).map(R); if (FINGER.test(b.name)) localQ[b.name] = [b.quaternion.x, b.quaternion.y, b.quaternion.z, b.quaternion.w].map((v) => Math.round(v * 1e5) / 1e5); }
+      for (const side of Object.keys(hands)) {
+        const h = hands[side]; const hp = h.getWorldPosition(new V()); const hq = h.getWorldQuaternion(new Q()).invert();
+        for (const b of bones) {
+          const f = FINGER.exec(b.name); if (!f || f[3].toLowerCase() !== side) continue;
+          const p = b.getWorldPosition(new V()).sub(hp).applyQuaternion(hq);
+          inHand[b.name] = [p.x, p.y, p.z].map(R);
+        }
+      }
+      frames.push({ t: Math.round(performance.now() - t0), body, inHand, localQ });
+      if (frames.length >= n) {
+        let rim = null, rimQ = null, rimNode = null, steer = null;
+        try {
+          const e = P.e(), root = e.object3d; const inv2 = P.inv();
+          const rn = (e.interior && (e.interior.steeringRim || e.interior.steering)) || root.getObjectByName('steering_rim') || root.getObjectByName('steering');
+          if (rn) { const pts = []; rn.traverse((m) => { if (m.isMesh && !m.isSkinnedMesh && m.geometry && m.geometry.attributes && m.geometry.attributes.position) P.meshPoints(m, inv2, 1500, pts); }); rim = pts.map(R); rimQ = P.bodyQuat(rn); rimNode = rn.name; }
+          steer = e.controller && e.controller.input ? e.controller.input.steer : null;
+        } catch (err) { /* keep nulls */ }
+        resolve({ frames, rim, rimQ, rimNode, steer, hands: Object.keys(hands) });
+        return;
+      }
+      requestAnimationFrame(step);
+    };
+    requestAnimationFrame(step);
+  });
+  /**
+   * NIGHT for the inspection frames: the test grounds have no time-of-day control, so dim the world's sun, sky,
+   * environment and exposure each frame (scene.onBeforeRender). The car's own lamps (spot lights, emissive lenses) are
+   * untouched. Ported from the vehicle-pipeline harness. P.setNight(false) restores every value.
+   */
+  P.setNight = (on, dim) => {
+    // dim: the fraction of the world's exposure kept (0.08 = black night, the harness's value; the inspection uses a dusk
+    // level so the body still reads beside its lit lamps)
+    const k = typeof dim === 'number' && dim > 0 ? dim : 0.08;
+    const sc = P.sceneRoot();
+    const st = (P.__night = P.__night || (() => {
+      const o = { s: sc, lights: [], envI: sc.environmentIntensity, bgI: sc.backgroundIntensity, bg: sc.background && sc.background.isColor ? sc.background.getHex() : null, fog: sc.fog && sc.fog.color ? sc.fog.color.getHex() : null, sky: null, prev: sc.onBeforeRender, on: false };
+      // every light of the WORLD (sun, sky fill, the test grounds' own spot lights on the pads); the car's own lamps stay
+      const car = P.root();
+      sc.traverse((l) => { if (l.isLight && !P.isUnder(l, car) && !/^portable-cabin-lamp|^portable-vehicle|headlamp|headlight/i.test(l.name || '')) o.lights.push({ l, i: l.intensity }); });
+      for (const m of sc.children) if (m.isMesh && m.material && m.material.name === 'HosekWilkieSkyShader') { const u = m.material.uniforms; o.sky = { m, scale: u.radianceScale ? u.radianceScale.value : undefined, disc: u.showSunDisc ? u.showSunDisc.value : undefined }; }
+      return o;
+    })());
+    if (on && !st.on) {
+      st.s.onBeforeRender = function (...a) {
+        const rd = a[0];
+        if (rd && typeof rd.toneMappingExposure === 'number') { if (st.lastExp === undefined || rd.toneMappingExposure !== st.lastExp) st.baseExp = rd.toneMappingExposure; rd.toneMappingExposure = st.baseExp * k; st.lastExp = rd.toneMappingExposure; st.rd = rd; }
+        for (const x of st.lights) x.l.intensity = x.i * k * 0.5;
+        // the environment keeps a moonlit share so the body still reads beside its lamps
+        st.s.environmentIntensity = Math.max(k * 0.4, Math.min(0.3, k * 0.9)); if (typeof st.s.backgroundIntensity === 'number') st.s.backgroundIntensity = k * 0.4;
+        if (st.s.background && st.s.background.isColor) st.s.background.setRGB(0.004, 0.006, 0.012);
+        if (st.s.fog && st.s.fog.color) st.s.fog.color.setRGB(0.004, 0.006, 0.012);
+        if (st.sky) { const u = st.sky.m.material.uniforms; if (typeof st.sky.scale === 'number') u.radianceScale.value = st.sky.scale * 0.02; if (u.showSunDisc) u.showSunDisc.value = false; }
+        return st.prev ? st.prev.apply(this, a) : undefined;
+      };
+      st.on = true;
+    } else if (!on && st.on) {
+      st.s.onBeforeRender = st.prev || (() => {}); st.on = false;
+      if (st.rd && st.baseExp !== undefined) st.rd.toneMappingExposure = st.baseExp; st.lastExp = undefined;
+      for (const x of st.lights) x.l.intensity = x.i;
+      st.s.environmentIntensity = st.envI; if (st.bgI !== undefined) st.s.backgroundIntensity = st.bgI;
+      if (st.bg != null) st.s.background.setHex(st.bg); if (st.fog != null) st.s.fog.color.setHex(st.fog);
+      if (st.sky) { const u = st.sky.m.material.uniforms; if (st.sky.scale !== undefined) u.radianceScale.value = st.sky.scale; if (u.showSunDisc) u.showSunDisc.value = st.sky.disc; }
+    }
+    return st.on;
+  };
+  G.__vqaVeh = P;
+  return true;
+})()`;
+/** Hide every positioned overlay (HUD, hints, menus) that does not contain the canvas, in one frame. */
+exports.HIDE_OVERLAYS = `(() => {
+  const els = document.querySelectorAll('body *');
+  let n = 0;
+  for (const el of els) {
+    if (el.tagName === 'CANVAS' || el.tagName === 'IFRAME' || el.dataset.vqaHidden) continue;
+    const pos = getComputedStyle(el).position;
+    if (pos !== 'fixed' && pos !== 'absolute' && pos !== 'sticky') continue;
+    if (el.querySelector('canvas,iframe')) continue;
+    el.dataset.vqaHidden = '1';
+    el.style.setProperty('visibility', 'hidden', 'important');
+    n++;
+  }
+  return n;
+})()`;
+//# sourceMappingURL=vehicleProbe.js.map