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

package/dist/visualQa/vehicle.js

@@ -0,0 +1,2002 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PER_RENDITION_ASSERT = exports.renderVehicle = exports.EVIDENCE_MAX = exports.VEHICLE_ROUTE_REVISION = void 0;
+exports.wheelFailsGeometry = wheelFailsGeometry;
+exports.tagRendition = tagRendition;
+exports.artifactUrl = artifactUrl;
+exports.unsealedRenditionErrors = unsealedRenditionErrors;
+exports.renditionPlan = renditionPlan;
+exports.waitPresented = waitPresented;
+exports.buildWheelRows = buildWheelRows;
+exports.bumperClearance = bumperClearance;
+// Vehicle render route. Loads the item in the hosted test grounds through Try Now (`?tryItem=<id>`, a signed-in QA
+// account), boards the driver's seat with the real E key, lets the car settle on its suspension, and then measures it
+// from the live scene graph — the DRAWN geometry, never node origins — against the live physics tuning:
+//
+//   vehicle.wheels.at_hubs           drawn wheel centres vs physics hubs, drawn count vs physics count, no shared hubs
+//   vehicle.wheels.arch_clearance    body poking into tyres, tyre top vs arch, ride height above the contact plane
+//   vehicle.wheels.spin_with_speed   drawn wheel rotation vs distance / radius while rolling forward
+//   vehicle.steering.wheel_rotates   front-wheel yaw and steering-wheel rotation at full lock
+//   vehicle.articulation.reaches_limits  every declared panel to its hinge limit and back, attached nodes rigid
+//   vehicle.seats.addressable        every declared seat in seat evidence, driver seat boardable
+//   + the four common asserts on the vehicle root
+//
+// Frames: six exterior views, four low square-on wheel close-ups, the driver's view, one per articulated panel at full
+// open, steering at full lock (front wheel + steering wheel), and the car rolling at speed in the chase view.
+// All camera poses are pinned in the BODY frame, so they show the car the same way whatever the spawn yaw.
+const vehicleDriveAlive_1 = require("./vehicleDriveAlive");
+const renditionManifest_1 = require("../vehicle/renditionManifest");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const browser_1 = require("./browser");
+const vehiclePreview_1 = require("./vehiclePreview");
+const vehicleStance_1 = require("./vehicleStance");
+const commonAsserts_1 = require("./commonAsserts");
+const resolve_1 = require("./resolve");
+const vehicleOccupants_1 = require("./vehicleOccupants");
+const vehiclePosture_1 = require("./vehiclePosture");
+const vehicleGrip_1 = require("./vehicleGrip");
+const vehicleInspection_1 = require("./vehicleInspection");
+const evidenceOverlay_1 = require("./evidenceOverlay");
+const vehiclePoses_1 = require("./vehiclePoses");
+const wheelDesign_1 = require("../vehicle/wheelDesign");
+const vehicleCabinFit_1 = require("./vehicleCabinFit");
+const vehicleClearance_1 = require("./vehicleClearance");
+const vehicleProbe_1 = require("./vehicleProbe");
+const vehicleAddonProbe_1 = require("./vehicleAddonProbe");
+const vehicleLamps_1 = require("./vehicleLamps");
+const previewSeats_1 = require("../vehicle/previewSeats");
+const previewAddon_1 = require("../vehicle/previewAddon");
+const vehicleMath_1 = require("./vehicleMath");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+exports.VEHICLE_ROUTE_REVISION = 'vehicle@2';
+/** Default action keys per panel signal (the vehicle HUD's own assignments). Verified live by the durable state flip. */
+const PANEL_KEYS = { doorFL: 'KeyO', doorFR: 'KeyP', doorRL: 'Semicolon', doorRR: 'Digit0', hood: 'Minus', trunk: 'Equal' };
+const FALLBACK_KEYS = ['KeyO', 'KeyP', 'Semicolon', 'Digit0', 'Quote', 'Minus', 'Equal', 'KeyQ', 'KeyZ'];
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const rd = (v, k = 1000) => (v === null || v === undefined || !Number.isFinite(v) ? null : Math.round(v * k) / k);
+function declaredPanels(root) {
+    const panels = (root?.mesh?.articulation?.panels ?? []);
+    return panels.filter((p) => p?.id && p?.hinge && Array.isArray(p.nodes) && p.nodes.length).map((p) => ({
+        id: String(p.id), signal: String(p.signal ?? p.id), role: String(p.role ?? ''), nodes: p.nodes.map(String),
+        hinge: { axis: p.hinge.axis, closedDeg: Number(p.hinge.closedDeg ?? 0), openDeg: Number(p.hinge.openDeg), pivot: p.hinge.pivot },
+    }));
+}
+function declaredSeats(root) {
+    const mod = root?.specialty?.module ?? {};
+    const seats = new Set(Object.keys(mod.seatVars ?? {}));
+    // The engine assumes the legacy key 'driver' when a manifest declares seatVars without naming its driver seat.
+    const driver = mod.driverSeat ? String(mod.driverSeat) : seats.has('driver') ? 'driver' : null;
+    if (driver)
+        seats.add(driver);
+    return { driver, seats: [...seats] };
+}
+async function vehiclePass(ctx, pass) {
+    const started = Date.now();
+    const itemId = ctx.resolved.identity.itemId;
+    const url = `${ctx.webBase.replace(/\/$/, '')}/play/universal-item-test-grounds?tryItem=${encodeURIComponent(itemId)}`;
+    const errors = [];
+    const measureOnly = pass.measureOnly;
+    const frames = [];
+    const asserts = [];
+    const facts = { routeRevision: exports.VEHICLE_ROUTE_REVISION, thresholds: vehicleMath_1.VEHICLE_QA_THRESHOLDS, rendition: pass.rendition, tierThatSelectsIt: pass.tier };
+    const timings = {};
+    const mark = (k) => { timings[k] = +((Date.now() - started) / 1000).toFixed(1); };
+    let renderer = null;
+    let engineVersion = null;
+    const scriptUrls = [];
+    const panels = declaredPanels(ctx.resolved.root);
+    const seatsDeclared = declaredSeats(ctx.resolved.root);
+    // Debug only: HELIX_VQA_VEHICLE_ONLY=occupants skips the wheel / panel / steering / drive phases (a partial run is never a verdict).
+    const preview = ctx.preview;
+    const envOnly = (process.env.HELIX_VQA_VEHICLE_ONLY ?? '').split(',').map((x) => x.trim()).filter(Boolean);
+    // A preview runs every phase but the occupants by default (`phases` names them explicitly); that is a chosen scope, not a partial debug run.
+    // `--addon`: the fitted add-ons are what is measured (no boarding, no stance, no drive); a baselineOnly pass reads the stock tuning.
+    const fittedAddOns = preview?.candidate.addOns ?? [];
+    const addOnMode = !!preview && (fittedAddOns.length > 0 || preview.baselineOnly === true);
+    // An add-on preview drives too: an add-on's audio delta over a car's audio block is what froze the R34 in Try Now.
+    const only = preview ? (addOnMode ? ['addons', 'drive'] : [...(preview.phases ?? ['exterior', 'poses', 'articulation', 'steering', 'cabin', 'drive']), ...(preview.paint ? ['paint'] : []), ...(preview.wheelFace ? ['wheelface'] : [])]) : envOnly;
+    const phase = (name) => (only.length === 0 || only.includes(name)) && !(measureOnly && MEASURE_ONLY_SKIPS.has(name));
+    if (!preview && envOnly.length)
+        errors.push(`HELIX_VQA_VEHICLE_ONLY=${envOnly.join(',')} was set: a partial debug run, not for submission`);
+    const previewSink = preview ? (0, vehiclePreview_1.newPreviewSink)() : null;
+    const occupantMeasures = [];
+    const occupantFailed = [];
+    const gripWindows = [];
+    const gripSeats = [];
+    const rigWarnings = [];
+    node_fs_1.default.mkdirSync(node_path_1.default.join(ctx.outDir, 'frames'), { recursive: true });
+    // geometry dumps of a non-default rendition go beside the default's, never over them
+    const dumpDir = measureOnly ? node_path_1.default.join(ctx.outDir, `rendition.${pass.rendition ?? 'x'}`) : ctx.outDir;
+    if (process.env.HELIX_VQA_DUMP_GEOMETRY)
+        node_fs_1.default.mkdirSync(dumpDir, { recursive: true });
+    const b = await (0, browser_1.launchVqaBrowser)({ storageState: ctx.storageState, executablePath: ctx.executablePath, width: 1440, height: 900 });
+    const { page } = b;
+    // A non-default rendition: the runtime asks for the model of the tier this machine resolves (the balanced one in a
+    // headless QA browser; measured 2026-10-03, a forced `low` Graphics setting does not reach the vehicle spawn), so it is
+    // handed that rendition's sealed bytes at that URL. The bytes are fetched here from the rendition's own artifact and
+    // must hash to its manifest CID; the pass then proves the page took them (`served`).
+    const sub = pass.substitute ?? null;
+    const subFacts = sub ? { from: sub.fromCid, to: sub.toCid, url: sub.url, served: 0 } : null;
+    if (sub && subFacts) {
+        facts.substitution = subFacts;
+        const fromHex = (0, resolve_1.hexOf)(sub.fromCid), toHex = (0, resolve_1.hexOf)(sub.toCid);
+        let bytes = null;
+        try {
+            const res = await fetch(sub.url, { headers: { 'user-agent': 'Mozilla/5.0 helix-visual-qa' } });
+            if (!res.ok)
+                throw new Error(`GET ${sub.url} -> ${res.status}`);
+            bytes = Buffer.from(await res.arrayBuffer());
+            const got = node_crypto_1.default.createHash('sha256').update(bytes).digest('hex');
+            subFacts.bytes = bytes.length;
+            subFacts.sha256 = got;
+            if (got !== toHex) {
+                errors.push(`rendition ${pass.rendition}: its artifact hashes to ${got.slice(0, 16)}…, not its manifest CID ${toHex?.slice(0, 16)}…`);
+                bytes = null;
+            }
+        }
+        catch (e) {
+            errors.push(`rendition ${pass.rendition}: could not fetch its sealed bytes (${String(e?.message ?? e).slice(0, 200)})`);
+        }
+        if (bytes && fromHex) {
+            const body = bytes;
+            await b.ctx.route((u) => u.href.includes(fromHex), async (route) => {
+                subFacts.served = Number(subFacts.served) + 1;
+                await route.fulfill({ status: 200, body, headers: { 'content-type': 'model/gltf-binary', 'cache-control': 'no-store', 'access-control-allow-origin': '*' } });
+            });
+        }
+    }
+    // Debug only: HELIX_VQA_DEBUG_ROUTES=<json file> [{ "match": "<url substring>", "file": "<local file>", "type": "<mime>" }]
+    // serves local bytes for matching requests (a candidate GLB in place of the pinned one, for calibration renders).
+    const debugRoutes = (process.env.HELIX_VQA_DEBUG_ROUTES ?? '').trim();
+    if (debugRoutes) {
+        errors.push(`HELIX_VQA_DEBUG_ROUTES=${debugRoutes} was set: a debug render with substituted bytes, not for submission`);
+        const rows = JSON.parse(node_fs_1.default.readFileSync(debugRoutes, 'utf8'));
+        for (const r of rows) {
+            const body = node_fs_1.default.readFileSync(r.file);
+            await b.ctx.route((u) => u.href.includes(r.match), (route) => route.fulfill({ status: 200, body, headers: { 'content-type': r.type ?? 'application/octet-stream', 'cache-control': 'no-store', 'access-control-allow-origin': '*' } }));
+        }
+    }
+    if (process.env.HELIX_VQA_FAULT_AUDIO_NAN)
+        errors.push('HELIX_VQA_FAULT_AUDIO_NAN was set: NaN was injected into every audio write during the drive (a proof of the drive check, not for submission)');
+    const engineOverride = (process.env.HELIX_VQA_ENGINE_RUNTIME ?? '').trim();
+    if (engineOverride)
+        errors.push(`HELIX_VQA_ENGINE_RUNTIME=${engineOverride} was set: a debug render on another engine, not for submission`);
+    // A candidate engine BUILD (a local humanoid-character dist/index.js) served in place of the runtime the platform resolves: the
+    // pre-release proof of an engine change on the real page, before it is published. Never a submission.
+    const engineBundle = (process.env.HELIX_VQA_ENGINE_BUNDLE ?? '').trim();
+    if (engineBundle)
+        errors.push(`HELIX_VQA_ENGINE_BUNDLE=${engineBundle} was set: rendered on a local engine build, not for submission`);
+    // ── THE OCCUPANT IS THE PLATFORM'S REFERENCE AVATAR, NOT THE SUBMITTER'S ───────────────────────────────────────────
+    // Every seat is occupied by "this account's own avatar", and an account's avatar is whatever it wears. MEASURED on the
+    // 993 (engine 0.3.214, same build, same car): the QA accounts' default avatar seats with torso 20.5°, hands on the rim,
+    // crown +25 mm; the owner's account, wearing a hairstyle whose cards stand ~0.11 m over the skull, seats reclined to the
+    // rig's stop (35.2°), hands 131/91 mm off the rim, hair +6 mm under the lining — seven occupant FAILs for whoever
+    // happened to submit. A car's gate has to judge the car, and the cabin fit is sized for the platform default body, so
+    // the page is answered with the platform default avatar (`GET /universal-items/avatar/default`, public) for every seat.
+    // `HELIX_VQA_OWN_AVATAR=1` keeps the account's own avatar (how YOUR avatar fits this car; recorded, not for submission);
+    // `HELIX_VQA_EQUIPPED_AVATAR=<json>` states any composition (debug, to bisect an avatar defect).
+    const equippedOverride = (process.env.HELIX_VQA_EQUIPPED_AVATAR ?? '').trim();
+    const ownAvatar = /^(1|true|yes)$/i.test((process.env.HELIX_VQA_OWN_AVATAR ?? '').trim());
+    let occupantAvatar = { source: 'account', itemId: null };
+    if (equippedOverride)
+        errors.push(`HELIX_VQA_EQUIPPED_AVATAR=${equippedOverride} was set: the occupants wear a stated avatar, not the reference one (debug, not for submission)`);
+    else if (ownAvatar)
+        errors.push('HELIX_VQA_OWN_AVATAR=1 was set: the occupants wear this account\'s own avatar, not the platform reference (not for submission)');
+    facts.occupantAvatar = occupantAvatar;
+    if (!ownAvatar) {
+        let body = null;
+        if (equippedOverride)
+            body = node_fs_1.default.readFileSync(equippedOverride, 'utf8');
+        else {
+            try {
+                const res = await fetch(`${ctx.apiBase.replace(/\/$/, '')}/api/v1/universal-items/avatar/default`, { headers: { accept: 'application/json' } });
+                if (res.ok)
+                    body = await res.text();
+                else
+                    errors.push(`occupants: the platform default avatar could not be read (HTTP ${res.status}); seats were filled with this account's avatar`);
+            }
+            catch (e) {
+                errors.push(`occupants: the platform default avatar could not be read (${String(e?.message ?? e).slice(0, 120)}); seats were filled with this account's avatar`);
+            }
+        }
+        if (body !== null) {
+            try {
+                const j = JSON.parse(body);
+                occupantAvatar = { source: equippedOverride ? 'stated' : 'platform-default', itemId: j.itemId ?? null };
+                facts.occupantAvatar = occupantAvatar;
+            }
+            catch { /* the page will say */ }
+            const answer = body;
+            await b.ctx.route(/\/universal-items\/avatar\/equipped\/me(\?|$)/, async (route) => {
+                if (route.request().method() !== 'GET') {
+                    await route.continue();
+                    return;
+                }
+                const origin = route.request().headers().origin;
+                await route.fulfill({ status: 200, body: answer, contentType: 'application/json', headers: { 'cache-control': 'no-store', ...(origin ? { 'access-control-allow-origin': origin, 'access-control-allow-credentials': 'true', vary: 'Origin' } : { 'access-control-allow-origin': '*' }) } });
+            });
+        }
+    }
+    if (preview && previewSink) {
+        await (0, vehiclePreview_1.installVehiclePreviewRoutes)(b.ctx, preview.candidate, itemId, previewSink);
+        (0, vehiclePreview_1.watchProxyModelFetches)(b.ctx, previewSink);
+    }
+    // Content-addressed model bytes (`/content/sha256/<2>/<hex>`) carry no file extension, so the shared asset filter
+    // misses them; record them here so the byte-identity check below can see what was actually fetched.
+    const contentUrls = [];
+    b.ctx.on('request', (req) => {
+        const u = req.url();
+        if (/\/index\.js(\?|$)|\/runtime\//.test(u) && scriptUrls.length < 200)
+            scriptUrls.push(u);
+        if (/\/content\/sha256\/|\/sha256[:/][0-9a-f]{64}/.test(u) && !contentUrls.includes(u))
+            contentUrls.push(u);
+    });
+    b.ctx.on('response', (res) => {
+        const v = res.headers()['x-helix-resolved-version'];
+        if (v && /humanoid-character\/runtime\//.test(res.url()) && !engineVersion)
+            engineVersion = v;
+    });
+    // Retired-runtime shim (asset-lab/porsche-911-993/qa/lib.mjs): an avatar swap disposed the WORLD-OWNED interaction host,
+    // making boarding impossible. Neutralised for this browser only, and only if the line is still in the bundle.
+    const shim = { scanned: 0, patched: 0, authorityGate: 0 };
+    const shimUrl = /(\/packages\/[^/]+\/[^/]+\/code|\/instant-packages\/humanoid-character\/runtime\/[^/]+)\/(index|addons)\.js(\?.*)?$/;
+    await b.ctx.route(shimUrl, async (route) => {
+        try {
+            const reqUrl = route.request().url();
+            const target = engineOverride ? reqUrl.replace(/(\/instant-packages\/humanoid-character\/runtime\/)[^/]+\//, `$1${encodeURIComponent(engineOverride)}/`) : reqUrl;
+            if (!/\/index\.js(\?|$)/.test(reqUrl) && target === reqUrl) {
+                await route.continue();
+                return;
+            }
+            const resp = await route.fetch(target === reqUrl ? undefined : { url: target });
+            let body = await resp.text();
+            shim.scanned++;
+            if (engineBundle && /\/instant-packages\/humanoid-character\/runtime\/[^/]+\/index\.js(\?|$)/.test(reqUrl)) {
+                body = node_fs_1.default.readFileSync(engineBundle, 'utf8');
+                engineVersion = /\bSYSTEM_VERSION\s*=\s*["']([^"']+)["']/.exec(body)?.[1] ?? engineVersion;
+            }
+            // the resolved version rides the 307 the redirect-following fetch consumed: read it off the bundle (`SYSTEM_VERSION`) instead
+            if (!engineVersion)
+                engineVersion = resp.headers()['x-helix-resolved-version'] ?? (/\bSYSTEM_VERSION\s*=\s*["']([^"']+)["']/.exec(body)?.[1] ?? null);
+            const needle = 'this.#options.interaction?.dispose?.();';
+            if (body.includes(needle)) {
+                body = body.split(needle).join('/* vqa-shim: interaction host is world-owned */');
+                shim.patched++;
+            }
+            // Preview only: the room reserved this car's entity from the PROXY's package, and the client refuses to draw a build
+            // whose digest differs from the room's (`authorityBuild !== requestedBuild` -> return, forever "still resolving").
+            // A candidate package necessarily differs, so the gate is lifted for this browser alone; the measurements are the
+            // client's own drawn geometry and controller tuning, which is what the candidate defines.
+            if (preview) {
+                const lifted = (0, vehiclePreview_1.liftAuthorityGate)(body);
+                if (lifted.lifted) {
+                    body = lifted.body;
+                    shim.authorityGate++;
+                }
+            }
+            // `body` is the DECODED text: a kept `content-encoding: br` (the CDN compresses the runtime bundle) makes the browser brotli-decode plain
+            // JavaScript, the shell shows "Something went wrong" and no vehicle is ever presented.
+            const out = { ...resp.headers(), 'content-length': '', 'cache-control': 'no-store', 'access-control-allow-origin': '*' };
+            delete out['content-encoding'];
+            delete out['transfer-encoding'];
+            await route.fulfill({ response: resp, body, headers: out });
+        }
+        catch {
+            await route.continue().catch(() => undefined);
+        }
+    });
+    // Debug only: HELIX_VQA_ENGINE_CORE=<version> serves that exact engine-core (the World's `@helix/engine-core/*` import
+    // map entries: audio, vehicle audio, ...) in place of the promoted one — e.g. to reproduce a fault an engine-core fix
+    // has since removed (the drive check's NaN-audio proof on 0.1.25). Recorded as a harness error: never a verdict.
+    const engineCorePin = (process.env.HELIX_VQA_ENGINE_CORE ?? '').trim();
+    if (engineCorePin) {
+        errors.push(`HELIX_VQA_ENGINE_CORE=${engineCorePin} was set: rendered on engine-core ${engineCorePin}, not the promoted one (debug, not for submission)`);
+        const probe = await fetch(`${ctx.apiBase.replace(/\/$/, '')}/api/v1/instant-packages/engine-core/runtime/${encodeURIComponent(engineCorePin)}/index.js`, { redirect: 'manual' });
+        const pinned = /\/packages\/([0-9a-f-]{36})\/([0-9a-f-]{36})\/code\//.exec(probe.headers.get('location') ?? '');
+        if (!pinned)
+            errors.push(`HELIX_VQA_ENGINE_CORE=${engineCorePin}: the platform resolves no such engine-core version`);
+        else {
+            const [, pkgId, versionId] = pinned;
+            const served = [];
+            const seen = [];
+            facts.engineCorePin = { version: engineCorePin, packageId: pkgId, versionId, served, seen };
+            b.ctx.on('request', (req) => { const u = req.url(); if ((u.includes(pkgId) || /engine-core/.test(u)) && seen.length < 40)
+                seen.push(u.slice(0, 200)); });
+            await b.ctx.route(new RegExp(`/packages/${pkgId}/(?!${versionId})[0-9a-f-]{36}/code/`), async (route) => {
+                const url = route.request().url().replace(new RegExp(`/packages/${pkgId}/[0-9a-f-]{36}/code/`), `/packages/${pkgId}/${versionId}/code/`);
+                if (served.length < 50)
+                    served.push(url.slice(url.indexOf('/code/')));
+                const resp = await route.fetch({ url });
+                const body = await resp.body();
+                // the fetched body is DECODED: a kept content-encoding would make the browser decode it a second time
+                const out = { ...resp.headers(), 'cache-control': 'no-store', 'access-control-allow-origin': '*' };
+                delete out['content-encoding'];
+                delete out['transfer-encoding'];
+                delete out['content-length'];
+                await route.fulfill({ status: resp.status(), body, headers: out });
+            });
+        }
+    }
+    // The site serves the platform runtime's addons through a cross-origin redirect that interception refuses (see browser.ts).
+    await (0, browser_1.installPlatformRuntimeCors)(b.ctx);
+    let frame = null;
+    let boarded = false;
+    const images = [];
+    const shot = async (id, label, group, settleMs = 450) => {
+        if (measureOnly)
+            return; // a non-default rendition is measured, never photographed for the critic
+        const file = node_path_1.default.join('frames', `${id}.jpg`);
+        await hideOverlays(page);
+        const dim = await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, file), settleMs);
+        frames.push({ id, label, group, file, width: dim.width, height: dim.height, subject: itemId });
+        images.push(await (0, commonAsserts_1.imageStats)(node_path_1.default.join(ctx.outDir, file)).catch(() => ({ file, lumaStdev: 0, meanLuma: 0 })));
+    };
+    // Evidence frames go INTO the bundle (and to the critic) in every pass, the measure-only ones too: a measured failure
+    // with no picture of it is one a reviewer cannot check. They are not counted by frame.non_empty (a cutaway is mostly sky).
+    const evidenceShot = async (id, label, group = 'evidence', overlay) => {
+        const file = node_path_1.default.join('frames', `${id}.jpg`);
+        await hideOverlays(page);
+        const dim = await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, file), 500);
+        if (overlay && frame) {
+            // the measured geometry, projected through the live camera, drawn over the capture (see evidenceOverlay.ts)
+            try {
+                const pts = (0, evidenceOverlay_1.overlayPoints)(overlay);
+                const pr = await frame.evaluate((flat) => globalThis.__vqaVeh.project(flat), pts);
+                const box = await (await frame.frameElement()).boundingBox().catch(() => null);
+                const vw = page.viewportSize()?.width ?? dim.width;
+                if (pr?.rect)
+                    await (0, evidenceOverlay_1.annotateFrame)(node_path_1.default.join(ctx.outDir, file), overlay, { ndc: pr.ndc, rect: pr.rect, frameOffset: { x: box?.x ?? 0, y: box?.y ?? 0 }, scale: dim.width / vw });
+                else
+                    errors.push(`evidence ${id}: the camera could not be read to draw the measured geometry`);
+            }
+            catch (e) {
+                errors.push(`evidence ${id}: drawing the measured geometry failed (${String(e?.message ?? e).slice(0, 160)})`);
+            }
+        }
+        return { id, label, group, file, width: dim.width, height: dim.height, subject: itemId };
+    };
+    const evidencePrefix = measureOnly && pass.rendition ? `evidence.${pass.rendition}.` : 'evidence.';
+    const ev = (fn) => frame.evaluate(fn);
+    const setCam = (c) => frame.evaluate((cc) => globalThis.__vqaVeh.setCam(cc), c);
+    const clearCam = () => frame.evaluate(() => globalThis.__vqaVeh.clearCam());
+    // results that asserts are built from (null = not measured)
+    let rows = null;
+    let physicsWheelCount = 0;
+    let duplicates = [];
+    let ride = null;
+    let stats = null;
+    const panelSweeps = [];
+    let lampJudgement = null;
+    let unoccupiedLamps = null;
+    let steering = null;
+    let spin = null;
+    let spinMode = 'keyboard';
+    let seatEvidence = null;
+    let bodyBounds = null;
+    let stanceMeasured = null;
+    let addOnProbe = null;
+    let addOnTuning = null;
+    try {
+        // ---------------------------------------------------------------------------------------------- load + identity
+        // One full re-load is allowed: a presentation that cannot be boarded is retried from navigation once before it
+        // is reported, and every attempt's diagnosis is kept in facts.attempts.
+        const attempts = [];
+        facts.attempts = attempts;
+        let board = { ok: false, reason: 'not attempted', tries: 0 };
+        const seatSends = [];
+        for (let attempt = 1; attempt <= 2; attempt++) {
+            await page.goto(url, { waitUntil: 'domcontentloaded' });
+            const presented = await waitPresented(page, 120_000, () => b.runtimeFaults[0] ? `the runtime refused to compose the car: ${b.runtimeFaults[0]}` : b.pageErrors[0] ? `the page raised an error before the car was presented: ${b.pageErrors[0]}` : null);
+            frame = presented.frame;
+            if (!frame) {
+                attempts.push({ attempt, presented: false, reason: presented.reason });
+                if (/refused/i.test(presented.reason) || attempt === 2)
+                    throw new Error(`the vehicle was never presented in the test grounds: ${presented.reason}`);
+                continue;
+            }
+            mark(attempt === 1 ? 'presented' : 'presented2');
+            renderer = await (0, browser_1.rendererInfo)(page);
+            await frame.evaluate(vehicleProbe_1.INSTALL_VEHICLE_PROBE);
+            await (0, commonAsserts_1.installSceneStats)(frame);
+            await page.waitForTimeout(1500);
+            const evidence = await ev(`(() => { const v = globalThis.__assetGym.mp.portableVehicleEvidence().vehicles[0]; return v ? { itemId: v.itemId, package: v.package, seats: v.seats, compositionDigest: v.compositionDigest, authoritativeBuild: v.authoritativeBuild } : null; })()`);
+            facts.runtimeEvidence = evidence;
+            if (!evidence)
+                errors.push('portableVehicleEvidence() reported no vehicle');
+            else {
+                if (evidence.itemId !== itemId)
+                    errors.push(`the runtime presented item ${evidence.itemId}, not ${itemId}`);
+                // A preview's package checksum is minted when the session is rewritten (it depends on the CDN origin the proxy serves from).
+                if (preview && previewSink?.sessions.length)
+                    ctx.resolved.identity.vehicleChecksum = previewSink.sessions[previewSink.sessions.length - 1].candidateChecksum;
+                const want = ctx.resolved.identity.vehicleChecksum;
+                const got = evidence.package?.checksumSha256 ?? null;
+                facts.packageIdentity = { pinnedVersion: ctx.resolved.identity.packageVersion, pinnedChecksum: want, runtimeRevision: evidence.package?.revision ?? null, runtimeChecksum: got, match: !!want && want === got };
+                if (!want)
+                    errors.push('the item has no properties.vehiclePackageIdentity.checksumSha256 to bind the render to');
+                else if (want !== got)
+                    errors.push(`the runtime served vehicle package checksum ${got ?? 'none'} (revision ${evidence.package?.revision ?? '?'}), not the pinned ${want} (${ctx.resolved.identity.packageVersion})`);
+            }
+            await page.mouse.click(720, 450).catch(() => undefined);
+            // ---------------------------------------------------------------------------------------------- board + settle
+            if (addOnMode) {
+                board = { ok: false, reason: 'not attempted (add-on preview measures the fitted parts, it does not drive)', tries: 0 };
+                attempts.push({ attempt, presented: true, board: false, reason: board.reason });
+                break;
+            }
+            // A preview boards with the CANDIDATE's own seat ids: the room only knows the stand-in's, so the seat request the client makes in the
+            // candidate's vocabulary is translated into the stand-in's at the room send (see vehicle/previewSeats.ts).
+            if (preview && previewSink?.sessions.length) {
+                const seatTable = previewSink.sessions[previewSink.sessions.length - 1]?.seats?.table;
+                const installed = seatTable ? await frame.evaluate(`(${previewSeats_1.INSTALL_SEAT_BRIDGE})(${JSON.stringify(seatTable)})`).catch((e) => ({ ok: false, why: String(e?.message ?? e).slice(0, 200) })) : { ok: false, why: 'no seat table (published car, or no session was rewritten)' };
+                facts.seatBridge = { installed, report: previewSink.sessions[previewSink.sessions.length - 1]?.seats ?? null, log: seatSends };
+            }
+            // the lamps with NOBODY in the car (parked, unoccupied): the other half of the brake-at-standstill decision
+            if (!addOnMode && phase('articulation')) {
+                try {
+                    const lp = (0, vehicleLamps_1.planLamps)(ctx.resolved.root);
+                    if (lp.functions.length > 0 && (await frame.evaluate(vehicleLamps_1.INSTALL_LAMP_PROBE)))
+                        unoccupiedLamps = await frame.evaluate((slots) => globalThis.__vqaLamps.snapshot(slots), lp.slots);
+                }
+                catch {
+                    unoccupiedLamps = null;
+                }
+            }
+            board = await boardDriver(page, frame, seatsDeclared.driver);
+            // the seat sends the client made this load, as the bridge saw them (a reload starts a new page, so read them per attempt)
+            const seatLog = preview && facts.seatBridge ? await frame.evaluate(() => globalThis.__vqaSeatLog ?? null).catch(() => null) : null;
+            if (seatLog)
+                seatSends.push(...seatLog.map((x) => ({ attempt, ...x })));
+            if (facts.seatBridge)
+                facts.seatBridge.log = seatSends;
+            attempts.push({ attempt, presented: true, board: board.ok, reason: board.reason, trace: board.trace, ...(seatLog ? { seatSends: seatLog.length } : {}) });
+            if (board.ok)
+                break;
+        }
+        if (!frame)
+            throw new Error('no world frame');
+        boarded = board.ok;
+        facts.board = board;
+        mark('boarded');
+        if (!boarded && !addOnMode)
+            errors.push(`could not board the driver seat after a full reload (${board.reason})`);
+        // An add-on preview does not drive: the parked car's wheel contacts never report grounded, and the fitted parts hang off the same nodes
+        // the hubs are read from, so a short pause (the models are fetched after the car spawns) replaces the settle.
+        const settle = addOnMode ? (await sleep(1500), { grounded: true, still: true, seconds: 1.5, last: null }) : await waitSettled(frame, boarded ? 9000 : 3000);
+        facts.settle = settle;
+        if (!settle.grounded)
+            errors.push(`the car never settled on all wheels (${JSON.stringify(settle.last)})`);
+        mark('settled');
+        // ---------------------------------------------------------------------------------------------- fitted add-ons
+        if (addOnMode) {
+            await frame.evaluate(vehicleAddonProbe_1.INSTALL_ADDON_PROBE);
+            // the engine mounts add-on models after the car spawns (it fetches their GLBs): wait until every fitted model is drawn, bounded
+            const wantIds = fittedAddOns.filter((a) => a.kind !== 'tune').map((a) => a.itemId);
+            const bindNames = fittedAddOns.flatMap((a) => { const b = a.frame?.bind; return typeof b?.root === 'string' ? [b.root] : []; });
+            const t0 = Date.now();
+            let read = { attach: [], hubs: [], rimNodes: [], carBounds: null };
+            for (;;) {
+                read = await frame.evaluate(({ ids, names }) => globalThis.__vqaAddon.read(ids, names), { ids: wantIds, names: bindNames });
+                const have = new Set(read.attach.map((a) => a.itemId));
+                if (wantIds.every((id) => have.has(id)) || Date.now() - t0 > 20_000)
+                    break;
+                await sleep(500);
+            }
+            await sleep(800); // let the suspension finish moving the wheels the add-on hangs off
+            read = await frame.evaluate(({ ids, names }) => globalThis.__vqaAddon.read(ids, names), { ids: wantIds, names: bindNames });
+            const tuning = await frame.evaluate(() => globalThis.__vqaAddon.tuning());
+            facts.addOn = { probe: read, tuning: preview?.baselineOnly ? tuning : { leaves: Object.keys(tuning).length }, waitedMs: Date.now() - t0 };
+            addOnTuning = tuning;
+            addOnProbe = read;
+            if (!preview?.baselineOnly)
+                stats = await ev('globalThis.__vqaVeh.stats()');
+            mark('addon-measured');
+            if (!preview?.baselineOnly) {
+                const car = read.carBounds;
+                const allMin = car ? [...car.min] : [-1, 0, -2.5];
+                const allMax = car ? [...car.max] : [1, 1.5, 2.5];
+                for (const a of read.attach) {
+                    if (a.min && a.max)
+                        for (let i = 0; i < 3; i++) {
+                            allMin[i] = Math.min(allMin[i], a.min[i]);
+                            allMax[i] = Math.max(allMax[i], a.max[i]);
+                        }
+                }
+                const groundY = Math.max(allMin[1], -1.2);
+                const carMin = [allMin[0], groundY, allMin[2]];
+                await setCam((0, vehicleMath_1.camFit)(carMin, allMax, [0.85, 0.35, 1], 30, 1.6, 0.86));
+                await shot('addon.front34', 'Fitted: front three-quarter (left)', 'exterior', 900);
+                await setCam((0, vehicleMath_1.camFit)(carMin, allMax, [-0.85, 0.35, -1], 30, 1.6, 0.86));
+                await shot('addon.rear34', 'Fitted: rear three-quarter (right)', 'exterior', 450);
+                const centre = car ? [(car.min[0] + car.max[0]) / 2, (car.min[1] + car.max[1]) / 2, (car.min[2] + car.max[2]) / 2] : [0, 0.5, 0];
+                for (const [index, a] of fittedAddOns.entries()) {
+                    const copies = read.attach.filter((x) => x.itemId === a.itemId && x.centre);
+                    if (a.kind === 'wheel') {
+                        for (const c of copies) {
+                            const [cx, cy, cz] = c.centre;
+                            const out = Math.sign(cx) || 1;
+                            const rad = c.min && c.max ? Math.max(c.max[1] - c.min[1], c.max[2] - c.min[2]) / 2 : 0.33;
+                            const dist = Math.max(1.5, rad * 6.2);
+                            await setCam({ pos: [cx + out * dist, cy + 0.06, cz], target: [cx, cy, cz], fov: 34, near: 0.05 });
+                            await shot(`addon.${index}.${(c.socketNode ?? c.name).replace(/[^a-z0-9]+/gi, '_')}`, `Add-on ${index + 1} ${a.title.slice(0, 24)} — ${c.socketNode ?? 'wheel'} square-on`, 'addons');
+                        }
+                    }
+                    else if (copies.length) {
+                        const c = copies[0];
+                        const [cx, cy, cz] = c.centre;
+                        const ext = c.min && c.max ? Math.max(c.max[0] - c.min[0], c.max[1] - c.min[1], c.max[2] - c.min[2]) : 0.5;
+                        let dx = cx - centre[0], dz = cz - centre[2];
+                        const dl = Math.hypot(dx, dz);
+                        if (dl < 0.2) {
+                            dx = -0.7;
+                            dz = -0.7;
+                        }
+                        else {
+                            dx /= dl;
+                            dz /= dl;
+                        }
+                        const dist = Math.max(0.9, ext * 1.9);
+                        await setCam({ pos: [cx + dx * dist, cy + dist * 0.4, cz + dz * dist], target: [cx, cy, cz], fov: 34, near: 0.05 });
+                        await shot(`addon.${index}.close`, `Add-on ${index + 1} ${a.title.slice(0, 28)} — close-up`, 'addons');
+                    }
+                    else if (a.kind === 'tune') {
+                        await setCam((0, vehicleMath_1.camFit)(carMin, allMax, [1, 0.3, 0.2], 30, 1.6, 0.86));
+                        await shot(`addon.${index}.car`, `Add-on ${index + 1} ${a.title.slice(0, 28)} (tuning only, nothing drawn)`, 'addons');
+                    }
+                }
+                await clearCam();
+            }
+            mark('addon-shots');
+            // An add-on preview DRIVES too, as the seated driver with the World's audio running: an add-on's audio delta over a
+            // car's audio block that lacked engineGainDb/exhaustGainDb made a NaN that froze the R34 in Try Now — a fault only
+            // visible with the add-on fitted, so only this run can catch it (vehicle.drive.responds_with_audio).
+            if (phase('drive') && !preview?.baselineOnly) {
+                try {
+                    const driver = await boardDriver(page, frame, seatsDeclared.driver);
+                    facts.addOnDriveBoard = { ok: driver.ok, reason: driver.reason, tries: driver.tries };
+                    if (!driver.ok) {
+                        asserts.push({ id: 'vehicle.drive.responds_with_audio', pass: false, severity: 'block', subject: itemId, detail: `could not board the driver to drive with the add-on(s) fitted (${driver.reason})` });
+                    }
+                    else {
+                        await waitSettled(frame, 9000);
+                        const driveRows = buildWheelRows(await ev('globalThis.__vqaVeh.pull()')).rows;
+                        const driveBounds = await ev('globalThis.__vqaVeh.bounds()');
+                        const d = await driveAndSample(page, frame, driveRows, shot, clearCam, driveBounds);
+                        const alive = (0, vehicleDriveAlive_1.judgeDriveAlive)(d.alive);
+                        facts.drive = d.facts;
+                        facts.driveAlive = alive.measured;
+                        asserts.push({ id: 'vehicle.drive.responds_with_audio', pass: alive.pass, severity: 'block', subject: itemId, detail: `${alive.detail} (add-on(s) fitted)`, measured: alive.measured });
+                        if (alive.harnessError)
+                            errors.push(alive.harnessError);
+                    }
+                }
+                catch (e) {
+                    const why = String(e?.message ?? e).slice(0, 200);
+                    errors.push(`drive with the add-on(s) fitted: ${why}`);
+                    if (!asserts.some((a) => a.id === 'vehicle.drive.responds_with_audio'))
+                        asserts.push({ id: 'vehicle.drive.responds_with_audio', pass: false, severity: 'block', subject: itemId, detail: `the drive could not complete with the add-on(s) fitted: ${why}` });
+                }
+                mark('drive');
+            }
+        }
+        else {
+            // ---------------------------------------------------------------------------------------------- wheel geometry
+            const pull = await ev('globalThis.__vqaVeh.pull()');
+            // the drawn wheels follow the instantaneous suspension, and a car rocks for seconds after the driver gets in:
+            // judge the wheels at the MEDIAN compression over a window, not at whatever instant the pull happened to catch
+            const window = await frame.evaluate((ms) => globalThis.__vqaVeh.compressionWindow(ms), 1500);
+            pull.compressionWindow = window.map((xs) => { const s = [...xs].sort((a, b) => a - b); return { n: s.length, min: s[0] ?? null, median: s.length ? s[Math.floor(s.length / 2)] : null, max: s[s.length - 1] ?? null }; });
+            physicsWheelCount = pull.wheels.length;
+            // raw geometry for offline re-analysis / threshold calibration (vehicle.spec.ts fixtures)
+            if (process.env.HELIX_VQA_DUMP_GEOMETRY)
+                node_fs_1.default.writeFileSync(node_path_1.default.join(dumpDir, 'geometry.json'), JSON.stringify(pull));
+            facts.batching = { batches: pull.batches, proxies: pull.proxies, bodyMeshes: pull.bodyMeshes, bodyVerts: pull.bodyVerts, excludedHardware: pull.excludedHardware };
+            const built = buildWheelRows(pull);
+            rows = built.rows;
+            duplicates = built.duplicates;
+            ride = built.ride;
+            facts.wheels = rows;
+            facts.rideHeight = ride;
+            facts.contactPlane = built.plane;
+            facts.strayWheelMeshes = pull.strays;
+            if (preview && rows) {
+                const m = (0, vehicleStance_1.measureStance)(rows, built.plane, ride, { physicsSettled: settle.grounded });
+                stanceMeasured = m;
+                facts.stance = { declared: (0, vehicleStance_1.declaredStance)(ctx.resolved.root), measured: m, settledBodyOriginWorld: settle.last?.p ?? null };
+            }
+            if (!physicsWheelCount)
+                errors.push('the live tuning has no wheel contacts');
+            stats = await ev('globalThis.__vqaVeh.stats()');
+            facts.drawnTriangles = stats?.triangles ?? null;
+            bodyBounds = await ev('globalThis.__vqaVeh.bounds()');
+            facts.bodyBounds = bodyBounds;
+            mark('measured');
+            // ---------------------------------------------------------------------------------------------- exterior + wheels
+            const groundY = built.plane[0];
+            const bb = bodyBounds;
+            const carMin = [bb.min[0], Math.max(bb.min[1], groundY), bb.min[2]];
+            const views = [
+                ['ext.front', 'Front', [0, 0.25, 1]],
+                ['ext.rear', 'Rear', [0, 0.25, -1]],
+                ['ext.left', 'Left side', [1, 0.12, 0]],
+                ['ext.right', 'Right side', [-1, 0.12, 0]],
+                ['ext.front34', 'Front three-quarter (left)', [0.85, 0.35, 1]],
+                ['ext.rear34', 'Rear three-quarter (right)', [-0.85, 0.35, -1]],
+            ];
+            if (phase('exterior'))
+                for (const [id, label, dir] of views) {
+                    await setCam((0, vehicleMath_1.camFit)(carMin, bb.max, dir, 30, 1.6, 0.86));
+                    await shot(id, label, 'exterior', id === 'ext.front' ? 900 : 450);
+                }
+            if (measureOnly) {
+                // one small diagnostic frame (kept beside the bundle, NOT in bundle.frames, so no critic ever sees it): proof the
+                // rendition drew something, and the input of frame.non_empty for this rendition
+                await setCam((0, vehicleMath_1.camFit)(carMin, bb.max, [0.85, 0.35, 1], 30, 1.6, 0.86));
+                await hideOverlays(page);
+                const file = node_path_1.default.join('frames', `rendition.${pass.rendition ?? 'x'}.front34.jpg`);
+                await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, file), 900);
+                images.push(await (0, commonAsserts_1.imageStats)(node_path_1.default.join(ctx.outDir, file)).catch(() => ({ file, lumaStdev: 0, meanLuma: 0 })));
+                facts.diagnosticFrame = file;
+                // a wheel this rendition draws wrong gets its own in-bundle frame, low and square-on like the default pass's
+                if (rows) {
+                    const shots = [];
+                    for (const r of rows) {
+                        if (!wheelFailsGeometry(r))
+                            continue;
+                        const c = r.drawnCentre ?? r.hub;
+                        const out = Math.sign(c[0]) || 1;
+                        const rad = r.radius ?? r.physicsRadius;
+                        // closer than the default pass's wheel frame, on the tyre's upper half and the arch over it, where the
+                        // overlap is: a 5 cm intrusion has to be more than a few pixels
+                        await setCam({ pos: [c[0] + out * Math.max(1.0, rad * 3.6), c[1] + rad * 0.55, c[2]], target: [c[0], c[1] + rad * 0.55, c[2]], fov: 34, near: 0.05 });
+                        const sfx = r.id.replace(/^wheel_/, '');
+                        const id = `evidence.${pass.rendition}.wheel.${sfx}`;
+                        // the cross-section at the wheel's centre plane, from the same pull the arch was measured on
+                        const pw = pull.wheels.find((w) => w.id === r.id);
+                        const g = pw?.axleNode ? (0, vehicleMath_1.wheelGeometry)(pw.points, pw.axleNode) : null;
+                        const sec = g ? (0, evidenceOverlay_1.wheelSectionOverlay)(g.centre, g.axle, g.radius, pull.bodyTris.tris, vehicleMath_1.VEHICLE_QA_THRESHOLDS.hubZoneFraction, {
+                            tyre: `tyre ${sfx.toUpperCase()}, cut through (r ${(g.radius * 100).toFixed(1)} cm)`,
+                            body: 'body, cut where it reaches deepest',
+                            overlap: `body inside the tyre (arch gap ${r.archGapM === null ? '?' : (r.archGapM * 100).toFixed(1)} cm)`,
+                        }, g.width) : null;
+                        frames.push(await evidenceShot(id, `Evidence: wheel ${sfx.toUpperCase()} on the ${pass.rendition} rendition, low and square-on, with the measured cross-section drawn over it: white = the tyre, yellow = the body cut across the tread, red = body inside the tyre. Measured arch gap ${r.archGapM === null ? '?' : (r.archGapM * 100).toFixed(1)} cm${r.penetrationCount ? `, body ${((r.maxPenetrationM ?? 0) * 100).toFixed(1)} cm inside the tyre` : ''}.`, 'evidence', sec?.overlay));
+                        shots.push(id);
+                    }
+                    facts.wheelEvidence = shots;
+                }
+            }
+            if (rows && phase('exterior')) {
+                for (const r of rows) {
+                    const c = r.drawnCentre ?? r.hub;
+                    const out = Math.sign(c[0]) || 1;
+                    const rad = r.radius ?? r.physicsRadius;
+                    const dist = Math.max(1.5, rad * 6.2);
+                    await setCam({ pos: [c[0] + out * dist, c[1] + 0.06, c[2]], target: [c[0], c[1] + rad * 0.3, c[2]], fov: 34, near: 0.05 });
+                    const sfx = r.id.replace(/^wheel_/, '');
+                    await shot(`wheel.${sfx}`, `Wheel ${sfx.toUpperCase()} — low, square-on`, 'wheels');
+                }
+            }
+            mark('exterior');
+            // ---------------------------------------------------------------------------------------------- appearance poses
+            // Preview only: the fixed, named views an author compares with the reference photos (vehiclePoses.ts). Written beside
+            // the bundle under poses/, never into bundle.frames (they are not judged, and frame.non_empty does not count them).
+            if (preview && !addOnMode && phase('poses')) {
+                const poseFacts = [];
+                facts.poses = poseFacts;
+                try {
+                    const driver = await frame.evaluate(() => {
+                        try {
+                            const c = globalThis.__vqaVeh.e().interior?.cabin;
+                            if (!c)
+                                return null;
+                            const s = c.seats.find((x) => x.role === 'driver') ?? c.seats[0];
+                            if (!s)
+                                return null;
+                            return { hip: [s.hipPoint[0], s.hipPoint[1], s.hipPoint[2]], rim: c.steering?.centre ? [c.steering.centre[0], c.steering.centre[1], c.steering.centre[2]] : null };
+                        }
+                        catch {
+                            return null;
+                        }
+                    });
+                    const plans = (0, vehiclePoses_1.planPoses)({ min: carMin, max: bb.max }, driver);
+                    const hid = await frame.evaluate(() => globalThis.__vqaVeh.backdrop(true));
+                    // every lamp and every local light off for the poses (a hotspot or bloom over the nose hides its shape); the lit
+                    // frames elsewhere keep the lamps and the world's lights as the runtime drives them
+                    const lightsOff = await frame.evaluate(() => globalThis.__vqaVeh.lightsOff(true)).catch((e) => ({ error: String(e?.message ?? e).slice(0, 160) }));
+                    facts.posesLightsOff = lightsOff;
+                    try {
+                        for (const pl of plans) {
+                            if (!pl.cam) {
+                                poseFacts.push({ id: pl.id, label: pl.label, file: null, why: pl.why });
+                                continue;
+                            }
+                            await setCam(pl.cam);
+                            await hideOverlays(page);
+                            const file = node_path_1.default.join('poses', `${pl.id}.jpg`);
+                            await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, file), pl.id === 'pose.front' ? 900 : 450);
+                            poseFacts.push({ id: pl.id, label: pl.label, file, camera: pl.cam, backdropHidden: hid });
+                        }
+                    }
+                    finally {
+                        await frame.evaluate(() => globalThis.__vqaVeh.lightsOff(false)).catch(() => undefined);
+                        await frame.evaluate(() => globalThis.__vqaVeh.backdrop(false));
+                        await clearCam();
+                    }
+                }
+                catch (e) {
+                    errors.push(`poses: ${String(e?.message ?? e).slice(0, 200)}`);
+                }
+            }
+            // ---------------------------------------------------------------------------------------------- wheel face
+            // Preview with --reference-wheel only. The front-left wheel photographed square-on along its axle, the tyre centred and
+            // filling WHEEL_FACE_FILL of the half-height, on the plain backdrop with every lamp off: the same view of every car, so
+            // vehicle/wheelDesign.ts can read spoke count, finish and centre cap from a known centre and radius.
+            if (preview && !addOnMode && preview.wheelFace && phase('wheelface')) {
+                const wf = { file: null };
+                facts.wheelFace = wf;
+                try {
+                    const r = (rows ?? []).find((x) => (x.drawnCentre ?? x.hub)[0] > 0) ?? (rows ?? [])[0];
+                    if (!r)
+                        throw new Error('no wheel geometry to frame');
+                    const c = r.drawnCentre ?? r.hub;
+                    const rad = r.radius ?? r.physicsRadius;
+                    const dist = (rad / wheelDesign_1.WHEEL_FACE_FILL) / Math.tan((wheelDesign_1.WHEEL_FACE_FOV / 2) * Math.PI / 180);
+                    const out = Math.sign(c[0]) || 1;
+                    await frame.evaluate(() => globalThis.__vqaVeh.backdrop(true));
+                    await frame.evaluate(() => globalThis.__vqaVeh.lightsOff(true)).catch(() => undefined);
+                    try {
+                        await setCam({ pos: [c[0] + out * dist, c[1], c[2]], target: [c[0], c[1], c[2]], fov: wheelDesign_1.WHEEL_FACE_FOV, near: 0.05 });
+                        await hideOverlays(page);
+                        const file = node_path_1.default.join('wheelface', 'candidate.jpg');
+                        await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, file), 700);
+                        wf.file = file;
+                        wf.wheel = r.id;
+                        wf.tyreRadiusM = rad;
+                    }
+                    finally {
+                        await frame.evaluate(() => globalThis.__vqaVeh.lightsOff(false)).catch(() => undefined);
+                        await frame.evaluate(() => globalThis.__vqaVeh.backdrop(false));
+                        await clearCam();
+                    }
+                }
+                catch (e) {
+                    errors.push(`wheelface: ${String(e?.message ?? e).slice(0, 200)}`);
+                }
+            }
+            // ---------------------------------------------------------------------------------------------- daylight paint sample
+            // Preview with --reference-paint only. The body paint ALONE (every other mesh hidden), lit
+            // exactly as the Try Now frame lights it: the world's sun, environment, exposure, tone mapping AND its local lights
+            // (the appearance poses switch the local lights off, which hid the bonnet hotspot an owner saw in Try Now). Six views,
+            // so a glare that only catches the top surfaces of a front three-quarter still counts. Judged by vehicle/paintHue.ts.
+            if (preview && !addOnMode && preview.paint && phase('paint')) {
+                const paintFacts = { views: [], materials: null };
+                facts.paint = paintFacts;
+                try {
+                    const plans = (0, vehiclePoses_1.planPoses)({ min: carMin, max: bb.max }, null).filter((pl) => pl.id !== 'pose.cockpit');
+                    paintFacts.lightingBefore = await frame.evaluate(() => globalThis.__vqaVeh.lighting()).catch((e) => String(e));
+                    await frame.evaluate(() => globalThis.__vqaVeh.backdrop(true));
+                    try {
+                        paintFacts.materials = await frame.evaluate(() => globalThis.__vqaVeh.paintOnly(true));
+                        for (const pl of plans) {
+                            if (!pl.cam) {
+                                paintFacts.views.push({ id: pl.id, file: null, why: pl.why });
+                                continue;
+                            }
+                            await setCam(pl.cam);
+                            await hideOverlays(page);
+                            const file = node_path_1.default.join('paint', `${pl.id.replace('pose.', 'paint.')}.jpg`);
+                            await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, file), 450);
+                            // the same camera with the paint hidden too: what the world draws behind the car, so the paint's pixels are exactly
+                            // the ones that differ (the sky and fog are drawn per camera angle, so no flat key colour holds)
+                            await frame.evaluate(() => globalThis.__vqaVeh.paintShow(false));
+                            const emptyFile = node_path_1.default.join('paint', `${pl.id.replace('pose.', 'empty.')}.jpg`);
+                            try {
+                                await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, emptyFile), 450);
+                            }
+                            finally {
+                                await frame.evaluate(() => globalThis.__vqaVeh.paintShow(true));
+                            }
+                            paintFacts.views.push({ id: pl.id, file, emptyFile });
+                        }
+                    }
+                    finally {
+                        await frame.evaluate(() => globalThis.__vqaVeh.paintOnly(false)).catch(() => undefined);
+                        await frame.evaluate(() => globalThis.__vqaVeh.backdrop(false));
+                        await clearCam();
+                    }
+                }
+                catch (e) {
+                    errors.push(`paint: ${String(e?.message ?? e).slice(0, 200)}`);
+                }
+            }
+            // ---------------------------------------------------------------------------------------------- articulation
+            if (boarded && phase('articulation')) {
+                for (const p of panels) {
+                    try {
+                        panelSweeps.push(await sweepPanel(page, frame, p, bb, shot, setCam));
+                    }
+                    catch (e) {
+                        errors.push(`articulation ${p.id}: ${String(e?.message ?? e).slice(0, 200)}`);
+                    }
+                }
+            }
+            facts.articulation = panelSweeps;
+            mark('articulation');
+            // ---------------------------------------------------------------------------------------------- lamps
+            // Press each lamp key as the seated driver and read the emissive of every mesh the package's lamp rows resolve to
+            // (vehicleLamps.ts). Runs with the articulation phase; a package with no lamp rows has nothing to sweep.
+            if (boarded && !addOnMode && (phase('lamps') || phase('articulation'))) {
+                try {
+                    const lampPlan = (0, vehicleLamps_1.planLamps)(ctx.resolved.root);
+                    if (lampPlan.functions.length > 0) {
+                        const sweep = await (0, vehicleLamps_1.runLampSweep)(page, frame, lampPlan);
+                        lampJudgement = sweep.samples.length > 0 ? (0, vehicleLamps_1.judgeLamps)({ plan: lampPlan, samples: sweep.samples, bounds: bodyBounds }) : null;
+                        facts.lamps = {
+                            plan: lampPlan, atRest: sweep.atRest, unoccupied: unoccupiedLamps ? { lights: unoccupiedLamps.lights, bits: unoccupiedLamps.bits, lenses: unoccupiedLamps.meshes.filter((m) => m.capable).map((m) => [m.name, m.lum]) } : null, errors: sweep.errors, judgement: lampJudgement,
+                            // the reads themselves, so a failing verdict can be audited line by line
+                            samples: sweep.samples.map((x) => ({ state: x.state, lights: x.snaps[x.snaps.length - 1]?.lights ?? [], reads: x.snaps.map((n) => n.meshes.filter((m) => m.capable || lampPlan.slots.some((sl) => m.aliases.includes(sl))).map((m) => [m.name, m.lum, m.box ? [m.box.min[2], m.box.max[2]] : null])) })),
+                        };
+                        if (sweep.errors.length)
+                            errors.push(...sweep.errors.map((x) => `lamps: ${x}`));
+                    }
+                }
+                catch (e) {
+                    errors.push(`lamps: ${String(e?.message ?? e).slice(0, 200)}`);
+                }
+            }
+            mark('lamps');
+            // ---------------------------------------------------------------------------------------------- inspection (preview)
+            // The gauntlet inspection set's exterior half: 8 angles by day and at night, and each lamp function lit at night
+            // (vehicleInspection.ts). Preview only, and never in the critic bundle: vehicle/inspectionSheets.ts lays it out.
+            if (preview && !addOnMode && boarded && phase('inspection')) {
+                try {
+                    node_fs_1.default.mkdirSync(node_path_1.default.join(ctx.outDir, 'inspection', 'frames'), { recursive: true });
+                    const insp = await (0, vehicleInspection_1.captureInspection)({
+                        page, frame, carMin, carMax: bb.max, setCam, clearCam,
+                        lampSignals: (0, vehicleLamps_1.planLamps)(ctx.resolved.root).functions.map((f) => f.signal),
+                        outDir: ctx.outDir,
+                        snap: async (id, settleMs) => {
+                            const file = node_path_1.default.join('inspection', 'frames', `${id}.jpg`);
+                            await hideOverlays(page);
+                            await (0, browser_1.captureJpeg)(page, node_path_1.default.join(ctx.outDir, file), settleMs);
+                            return file;
+                        },
+                    });
+                    facts.inspection = insp;
+                    if (insp.errors.length)
+                        errors.push(...insp.errors.map((x) => `inspection: ${x}`));
+                }
+                catch (e) {
+                    errors.push(`inspection: ${String(e?.message ?? e).slice(0, 200)}`);
+                }
+            }
+            mark('inspection');
+            // ---------------------------------------------------------------------------------------------- steering
+            if (boarded && rows && phase('steering')) {
+                try {
+                    steering = await steeringSweep(page, frame, rows, shot, setCam, clearCam);
+                    facts.steering = steering.measured;
+                }
+                catch (e) {
+                    errors.push(`steering: ${String(e?.message ?? e).slice(0, 200)}`);
+                }
+            }
+            mark('steering');
+            // ---------------------------------------------------------------------------------------------- driver's view
+            if (boarded && phase('cabin')) {
+                try {
+                    await clearCam();
+                    const fp = await setCameraMode(page, frame, 'first-person');
+                    facts.cabinCamera = fp;
+                    await shot('cabin.driver', "Driver's view (first person)", 'cabin', 900);
+                    await setCameraMode(page, frame, 'third-person');
+                }
+                catch (e) {
+                    errors.push(`cabin view: ${String(e?.message ?? e).slice(0, 200)}`);
+                }
+            }
+            mark('cabin');
+            // ---------------------------------------------------------------------------------------------- drive + spin
+            if (boarded && rows && phase('drive')) {
+                try {
+                    const d = await driveAndSample(page, frame, rows, shot, clearCam, bodyBounds);
+                    spin = d.spin;
+                    spinMode = d.mode;
+                    facts.drive = d.facts;
+                    const alive = (0, vehicleDriveAlive_1.judgeDriveAlive)(d.alive);
+                    facts.driveAlive = alive.measured;
+                    asserts.push({ id: 'vehicle.drive.responds_with_audio', pass: alive.pass, severity: 'block', subject: itemId, detail: alive.detail, measured: alive.measured });
+                    if (alive.harnessError)
+                        errors.push(alive.harnessError);
+                    if (process.env.HELIX_VQA_DEBUG_PARK_AT_WALL)
+                        errors.push('HELIX_VQA_DEBUG_PARK_AT_WALL was set: the drive parked the car against the scenery ahead (a debug run, not for submission)');
+                }
+                catch (e) {
+                    const why = String(e?.message ?? e).slice(0, 200);
+                    errors.push(`drive: ${why}`);
+                    if (!asserts.some((a) => a.id === 'vehicle.drive.responds_with_audio'))
+                        asserts.push({ id: 'vehicle.drive.responds_with_audio', pass: false, severity: 'block', subject: itemId, detail: `the drive could not complete: ${why}` });
+                }
+            }
+            mark('drive');
+            seatEvidence = await ev(`(() => { const v = globalThis.__assetGym.mp.portableVehicleEvidence().vehicles[0]; const l = globalThis.__assetGym.mp.seatEvidence?.().local; return { seats: v?.seats ?? [], occupied: v?.occupiedSeats ?? null, seated: l?.seated ? { seatId: l.seated.seatId, role: l.seated.role } : null }; })()`).catch(() => null);
+            facts.seats = { declared: seatsDeclared, evidence: seatEvidence, boardedAs: facts.board?.seated ?? null };
+            mark('seats');
+            // ---------------------------------------------------------------------------------------------- occupants
+            // Last, because it leaves the driver's seat: every declared seat gets a real occupant (this account's own avatar,
+            // walked to the door and seated with the real E key), measured against the DRAWN cabin and photographed from outside.
+            if (boarded && phase('occupants')) {
+                try {
+                    const occ = await (0, vehicleOccupants_1.captureOccupants)({
+                        page, frame, itemId, panels, seatsDeclared, seatEvidence: seatEvidence?.seats ?? [], carBounds: bodyBounds, outDir: dumpDir, shot, setCam, clearCam,
+                        evidence: (id, label, group, overlay) => evidenceShot(id, label, group, overlay), evidencePrefix,
+                    });
+                    // the worst EVIDENCE_MAX clashes of the whole car (they were already deduped per seat, body part and cabin part)
+                    const kept = [...occ.evidence].sort((x, y) => y.score - x.score).slice(0, exports.EVIDENCE_MAX);
+                    for (const e of occ.evidence) {
+                        if (kept.includes(e))
+                            frames.push(e.shot);
+                        else
+                            node_fs_1.default.rmSync(node_path_1.default.join(ctx.outDir, e.shot.file), { force: true });
+                    }
+                    facts.penetrationEvidence = kept.map((e) => e.id);
+                    occupantMeasures.push(...occ.measures);
+                    occupantFailed.push(...occ.failed);
+                    gripWindows.push(...occ.grip);
+                    gripSeats.push(...occ.seated);
+                    rigWarnings.push(...occ.rigWarnings);
+                    facts.occupants = occ.facts;
+                }
+                catch (e) {
+                    errors.push(`occupants: ${String(e?.message ?? e).slice(0, 300)}`);
+                }
+            }
+            mark('occupants');
+        }
+    }
+    catch (e) {
+        errors.push(String(e?.message ?? e).slice(0, 400));
+        await page.screenshot({ path: node_path_1.default.join(ctx.outDir, 'frames', 'error.jpg'), type: 'jpeg', quality: 70 }).catch(() => undefined);
+    }
+    finally {
+        facts.shim = shim;
+        facts.pageErrors = b.pageErrors.slice(0, 20);
+        engineVersion = engineVersion ?? engineVersionFrom(scriptUrls);
+        facts.runtimeScripts = [...new Set(scriptUrls.filter((u) => /index\.js/.test(u)))].slice(0, 20);
+        // closing with live route handlers / a running world can stall Playwright for ~30 s: drop the routes and the
+        // world first (bounded), then close
+        await b.ctx.unrouteAll({ behavior: 'ignoreErrors' }).catch(() => undefined);
+        await page.goto('about:blank', { timeout: 5000 }).catch(() => undefined);
+        await Promise.race([b.close().catch(() => undefined), sleep(15_000)]);
+        mark('closed');
+    }
+    // ---------------------------------------------------------------------------------------------------- asserts
+    const notMeasured = (id, why) => ({ id, pass: false, severity: 'block', subject: itemId, detail: `not measured: ${why}` });
+    if (addOnMode) {
+        if (!preview?.baselineOnly && addOnProbe) {
+            const stock = preview?.stockTuning ?? null;
+            for (const [index, addOn] of fittedAddOns.entries()) {
+                const tuning = addOn.kind === 'tune' && stock && addOnTuning ? (0, previewAddon_1.judgeTuneOps)(addOn, stock, addOnTuning) : null;
+                for (const v of (0, previewAddon_1.judgeAddOn)(index, addOn, addOnProbe, { toleranceCm: preview?.toleranceCm, tuning })) {
+                    asserts.push({ id: v.id, pass: v.pass, severity: v.severity, subject: itemId, detail: v.detail, ...(v.measured ? { measured: v.measured } : {}) });
+                }
+            }
+        }
+        else if (!preview?.baselineOnly)
+            errors.push('the fitted add-ons were never measured');
+    }
+    else {
+        if (rows) {
+            const h = (0, vehicleMath_1.judgeAtHubs)(rows, physicsWheelCount, duplicates);
+            asserts.push({ id: 'vehicle.wheels.at_hubs', pass: h.pass, severity: 'block', subject: itemId, detail: h.detail, measured: h.measured });
+            const a = (0, vehicleMath_1.judgeArchClearance)(rows, ride ?? { minM: null, mesh: null, at: null });
+            asserts.push({ id: 'vehicle.wheels.arch_clearance', pass: a.pass, severity: 'block', subject: itemId, detail: a.detail, measured: a.measured });
+            const rr = (0, vehicleMath_1.judgeRadius)(rows);
+            asserts.push({ id: 'vehicle.wheels.radius_matches_physics', pass: rr.pass, severity: 'warn', subject: itemId, detail: rr.detail, measured: rr.measured });
+        }
+        else {
+            asserts.push(notMeasured('vehicle.wheels.at_hubs', 'the wheel geometry was never read'), notMeasured('vehicle.wheels.arch_clearance', 'the wheel geometry was never read'));
+        }
+    }
+    if (preview) {
+        const declared = (0, vehicleStance_1.declaredStance)(ctx.resolved.root);
+        if (addOnMode) { /* the stance and wheel judgements belong to the car preview; an add-on preview judges the fitted parts */ }
+        else {
+            if (stanceMeasured) {
+                const st = (0, vehicleStance_1.judgeStance)(declared, stanceMeasured);
+                asserts.push({ id: 'preview.stance.ride_height', pass: st.pass, severity: 'block', subject: itemId, detail: st.detail, measured: st.measured });
+            }
+            else
+                asserts.push(notMeasured('preview.stance.ride_height', 'the wheel geometry was never read'));
+            if (rows) {
+                const wb = (0, vehicleStance_1.judgeWheelBinding)(rows, (facts.strayWheelMeshes ?? []));
+                asserts.push({ id: 'preview.wheels.bound_to_hubs', pass: wb.pass, severity: 'block', subject: itemId, detail: wb.detail, measured: wb.measured });
+            }
+            const sum = (0, vehicleStance_1.judgeDeclaredSum)(declared);
+            asserts.push({ id: 'preview.stance.declared_consistent', pass: sum.pass, severity: 'warn', subject: itemId, detail: sum.detail, measured: sum.measured });
+            if (spin && rows) {
+                const roll = (0, vehicleStance_1.rollingRadii)(spin, rows.map((r) => r.rollRadius ?? r.physicsRadius));
+                facts.rollingRadius = roll;
+                const rv = (0, vehicleStance_1.judgeRollingRadius)(roll, declared.wheelRadiusM);
+                asserts.push({ id: 'preview.wheels.rolling_radius', pass: rv.pass, severity: 'warn', subject: itemId, detail: rv.detail, measured: rv.measured });
+            }
+            else
+                asserts.push(notMeasured('preview.wheels.rolling_radius', boarded ? 'the drive did not complete' : 'could not board to drive'));
+        }
+        facts.preview = {
+            proxyItem: itemId,
+            authorityGateLifted: shim.authorityGate,
+            sessionsRewritten: previewSink?.sessions.length ?? 0,
+            sessionMisses: previewSink?.sessionMisses ?? [],
+            candidateGlbServedFromDisk: previewSink?.glbServed ?? 0,
+            candidateAudioServedFromDisk: previewSink?.audioServed ?? 0,
+            proxyModelFetched: previewSink?.proxyModelFetched ?? [],
+            thresholds: vehicleStance_1.STANCE_THRESHOLDS,
+        };
+        if (shim.authorityGate === 0 && previewSink?.sessions.some((x) => x.candidateChecksum !== x.proxyChecksum))
+            errors.push('the runtime bundle has no `authorityBuild !== requestedBuild` gate to lift (the engine changed), so a candidate that differs from its proxy cannot be drawn; the preview shim needs updating');
+        if (!previewSink?.sessions.length)
+            errors.push(`the Try Now session of proxy item ${itemId} was never rewritten, so the candidate was not served${previewSink?.sessionMisses.length ? ` (${previewSink.sessionMisses.join('; ')})` : ''}`);
+        else if (!previewSink.glbServed && preview.candidate.keepCar !== true)
+            errors.push('the candidate GLB was never fetched from disk, so the runtime drew some other model');
+        for (const a of fittedAddOns)
+            if (a.kind !== 'tune' && a.glb && !previewSink?.addOnGlbServed[a.itemId] && !preview.baselineOnly)
+                errors.push(`the add-on model for ${a.title} was never fetched from disk, so the runtime did not draw it`);
+        facts.preview = { ...facts.preview, addOns: previewSink?.sessions[previewSink.sessions.length - 1]?.addOns ?? [], addOnGlbServedFromDisk: previewSink?.addOnGlbServed ?? {}, compositionDigest: previewSink?.sessions[previewSink.sessions.length - 1]?.compositionDigest ?? null };
+        if (previewSink?.proxyModelFetched.length)
+            errors.push(`the proxy's own model was fetched (${previewSink.proxyModelFetched.map((u) => u.slice(-24)).join(', ')}), so the runtime may have drawn the proxy car, not the candidate`);
+    }
+    if (!addOnMode) {
+        if (spin) {
+            asserts.push({
+                id: 'vehicle.wheels.spin_with_speed', pass: spin.pass, severity: 'block', subject: itemId,
+                detail: spin.pass
+                    ? `rolling ${spin.distanceM.toFixed(1)} m in ${spin.seconds.toFixed(2)} s (${spinMode}), every drawn wheel turned with distance/radius (ratios ${spin.wheels.map((w) => w.ratio?.toFixed(2)).join(', ')})`
+                    : `drawn wheel spin does not follow speed: ${spin.reason} (${spinMode})`,
+                measured: { mode: spinMode, ...spin },
+            });
+        }
+        else if (!measureOnly)
+            asserts.push(notMeasured('vehicle.wheels.spin_with_speed', boarded ? 'the drive did not complete' : 'could not board to drive'));
+        if (steering)
+            asserts.push({ id: 'vehicle.steering.wheel_rotates', pass: steering.pass, severity: 'block', subject: itemId, detail: steering.detail, measured: steering.measured });
+        else if (!measureOnly)
+            asserts.push(notMeasured('vehicle.steering.wheel_rotates', boarded ? 'the steering sweep did not complete' : 'could not board to steer'));
+        if (boarded) {
+            const verdicts = panelSweeps.map((p) => ({ p, v: (0, vehicleMath_1.judgePanel)(p) }));
+            const missing = panels.filter((p) => !panelSweeps.some((s) => s.id === p.id)).map((p) => p.id);
+            const failed = verdicts.filter((x) => !x.v.pass);
+            asserts.push({
+                id: 'vehicle.articulation.reaches_limits', pass: failed.length === 0 && missing.length === 0, severity: 'block', subject: itemId,
+                detail: !panels.length ? 'the package declares no articulated panels'
+                    : missing.length ? `${missing.join(', ')} could not be operated`
+                        : failed.length ? failed.map((x) => x.v.why).join('; ')
+                            : `${panels.length} panels reach their declared limits and close: ${verdicts.map((x) => x.v.why).join(', ')}`,
+                measured: { panels: panelSweeps, missing },
+            });
+        }
+        else
+            asserts.push(notMeasured('vehicle.articulation.reaches_limits', 'could not board to operate the panels'));
+        if (lampJudgement)
+            asserts.push({ id: 'vehicle.lamps.each_function_lights', pass: lampJudgement.pass, severity: 'block', subject: itemId, detail: lampJudgement.detail, measured: { functions: lampJudgement.functions, darkLenses: lampJudgement.darkLenses, skipped: lampJudgement.skipped } });
+        {
+            const { absent, resolved, driverId } = (0, vehicleMath_1.resolveDeclaredSeats)(seatsDeclared, seatEvidence?.seats ?? []);
+            const seatedId = facts.board?.seated?.seatId ?? null;
+            const driverOk = boarded && (!seatsDeclared.driver || seatedId === driverId);
+            const shown = seatsDeclared.seats.map((s) => (resolved[s] && resolved[s] !== s ? `${s} -> ${resolved[s]}` : s));
+            asserts.push({
+                id: 'vehicle.seats.addressable', pass: !!seatEvidence && absent.length === 0 && driverOk && seatsDeclared.seats.length > 0, severity: 'block', subject: itemId,
+                detail: !seatEvidence ? 'no seat evidence was read'
+                    : !seatsDeclared.seats.length ? 'the package declares no seats'
+                        : absent.length ? `declared seats missing from seat evidence: ${absent.join(', ')}`
+                            : !driverOk ? `driver seat ${seatsDeclared.driver} could not be boarded (seated: ${seatedId ?? 'none'})`
+                                : `${seatsDeclared.seats.length} declared seats present (${shown.join(', ')}); boarded ${seatedId} as driver`,
+                measured: { declared: seatsDeclared, evidence: seatEvidence?.seats ?? null, seated: seatedId, resolved },
+            });
+        }
+        const seatBridge = facts.seatBridge;
+        if (preview && !addOnMode && seatBridge?.report) {
+            const rep = seatBridge.report;
+            const seatedId = facts.board?.seated?.seatId ?? null;
+            const candidateSeats = new Set([...rep.candidate.declaredCabinSeats, ...rep.candidate.glbSeatNodes]);
+            const key = seatedId ? rep.table.candidateKeyForCabin[seatedId] ?? null : null;
+            const sends = seatBridge.log ?? [];
+            const ok = boarded && !!seatedId && candidateSeats.has(seatedId);
+            asserts.push({
+                id: 'preview.seats.candidate_ids_used', pass: ok, severity: 'block', subject: itemId,
+                detail: ok ? `boarded the candidate's own seat ${seatedId}${key ? ` (its manifest key "${key}")` : ''}; the room, which holds the stand-in's seats (${rep.proxy.keys.join(', ') || 'none'}), was asked in its own vocabulary: ${sends.length ? `${sends.filter((x) => x.translated).length} of ${sends.length} seat send(s) translated` : rep.table.identical ? 'the two vocabularies already agree, nothing rewritten' : 'no seat send was observed'}`
+                    : !boarded ? `could not board with the candidate's seat ids (candidate seats ${[...candidateSeats].join(', ') || 'none'}, key ${rep.candidate.driverKey ?? 'none'}; stand-in seats ${rep.proxy.keys.join(', ') || 'none'}); ${rep.table.problems.join('; ') || (seatBridge.installed?.ok === false ? `the seat bridge was not installed (${seatBridge.installed.why})` : 'the room refused the seat request')}`
+                        : `seated in ${seatedId}, which is not one of the candidate's seats (${[...candidateSeats].join(', ')}): the stand-in's seat was used`,
+                measured: { candidateSeatIds: [...candidateSeats], candidateKeys: rep.candidate.keys, standInKeys: rep.proxy.keys, seated: seatedId, seatedKey: key, identical: rep.table.identical, unmapped: rep.table.unmapped, sends },
+            });
+        }
+        if (phase('occupants')) {
+            const { resolved } = (0, vehicleMath_1.resolveDeclaredSeats)(seatsDeclared, seatEvidence?.seats ?? []);
+            const declared = seatsDeclared.seats;
+            if (boarded) {
+                for (const v of [...(0, vehicleMath_1.judgeOccupants)(occupantMeasures, occupantFailed, declared, engineVersion), ...(0, vehiclePosture_1.judgePosture)(occupantMeasures), ...(0, vehicleGrip_1.judgeGrip)(gripWindows, gripSeats), (0, vehicleGrip_1.judgeSeatRigWarnings)(rigWarnings, gripSeats.length)]) {
+                    asserts.push({ id: v.id, pass: v.pass, severity: v.severity ?? 'block', subject: itemId, detail: v.detail, measured: v.measured });
+                }
+            }
+            else {
+                for (const id of ['vehicle.occupants.engine_current', 'vehicle.occupants.boarded', 'vehicle.occupants.head_clearance', 'vehicle.occupants.hips_on_seat', 'vehicle.occupants.feet_on_floor', 'vehicle.occupants.hands_on_wheel', 'vehicle.occupants.penetration', 'vehicle.occupants.torso_angle', 'vehicle.occupants.knees_up', 'vehicle.occupants.head_in_wings', ...vehicleGrip_1.GRIP_ASSERT_IDS]) {
+                    asserts.push(notMeasured(id, 'could not board to seat an occupant'));
+                }
+            }
+            facts.occupantEngine = { engineVersion, min: vehicleMath_1.OCCUPANT_MIN_ENGINE, declared, resolved };
+            // Preview: did the runtime seat each occupant where the package put the seat? (its cabin fit moves seats silently)
+            if (preview && !addOnMode) {
+                const seatsSeen = (facts.occupants?.seats ?? []).filter((x) => x.seatId);
+                if (boarded && seatsSeen.length) {
+                    const cf = (0, vehicleCabinFit_1.judgeCabinFit)(seatsSeen);
+                    facts.cabinFit = { rows: cf.rows, report: cf.report, thresholds: vehicleCabinFit_1.CABIN_FIT_THRESHOLDS };
+                    asserts.push({ id: 'preview.occupants.cabin_fit', pass: cf.pass, severity: 'block', subject: itemId, detail: cf.detail, measured: { rows: cf.rows, maxMoveM: vehicleCabinFit_1.CABIN_FIT_THRESHOLDS.maxMoveM, steering: cf.report?.steering ?? null, pedals: cf.report?.pedals ?? null, driverFit: cf.report?.driverFit ?? null, warnings: cf.report?.warnings ?? [] } });
+                }
+                else
+                    asserts.push(notMeasured('preview.occupants.cabin_fit', boarded ? 'no seat was occupied' : 'could not board to seat an occupant'));
+            }
+        }
+    }
+    if (stats)
+        asserts.push(...(0, commonAsserts_1.commonAsserts)('vehicle', stats, images, { subject: itemId }));
+    else if (!preview?.baselineOnly)
+        errors.push('scene stats were never read');
+    // ---------------------------------------------------------------------------------------------------- byte identity
+    const keepCar = preview?.candidate.keepCar === true;
+    const modelHex = keepCar ? null : (0, resolve_1.hexOf)(pass.modelCid);
+    facts.modelCid = pass.modelCid;
+    if (!modelHex && !keepCar)
+        errors.push('the resolved version names no model CID to check the rendered bytes against');
+    const fetched = [...new Set([...b.fetchedAssets, ...contentUrls])];
+    facts.modelFetchedFrom = fetched.filter((u) => modelHex && u.includes(modelHex));
+    facts.contentFetched = contentUrls.map((u) => /[0-9a-f]{64}/.exec(u)?.[0] ?? u).slice(0, 40);
+    if (subFacts) {
+        if (!Number(subFacts.served))
+            errors.push(`rendition ${pass.rendition}: the runtime never requested the model it was to be served in place of (${String(subFacts.from).slice(0, 24)}…)`);
+    }
+    else if (!modelHex) { /* reported above, or a published car's own bytes (--item) */ }
+    else if (!fetched.some((u) => u.includes(modelHex)))
+        errors.push(`rendered bytes are not the pinned model: no fetched asset URL contains ${modelHex.slice(0, 16)}…`);
+    timings.total = +((Date.now() - started) / 1000).toFixed(1);
+    facts.timings = timings;
+    ctx.log('vehicle.timings', timings);
+    return {
+        route: 'test-grounds', url, frames, asserts, facts,
+        subjects: [{ id: itemId, title: ctx.resolved.identity.title, role: 'host' }],
+        errors: [...new Set(errors)], renderer, engineVersion, fetchedAssets: fetched,
+    };
+}
+/** Phases a measure-only (non-default rendition) pass skips: steering and the drive are rendition-independent physics,
+ *  the cabin view is a frame. */
+const MEASURE_ONLY_SKIPS = new Set(['steering', 'cabin', 'drive']);
+/** In-bundle clipping evidence frames per pass (rendition): the worst clashes only, each one a different place. */
+exports.EVIDENCE_MAX = 3;
+/** A wheel whose drawn geometry fails at_hubs or arch_clearance on its own (the same per-wheel criteria they judge). */
+function wheelFailsGeometry(r, t = vehicleMath_1.VEHICLE_QA_THRESHOLDS) {
+    const d = r.delta;
+    const offHub = !!d && (Math.hypot(d[0], d[2]) > t.hubPlanarTolM || Math.abs(d[1]) > t.hubVerticalTolM);
+    const tucked = r.archGapM !== null && r.archGapM !== undefined && r.archGapM < t.archGapMinM;
+    const poked = (r.penetrationCount ?? 0) > t.penetrationMaxCount && (r.maxPenetrationM ?? 0) > t.penetrationDepthM;
+    return offHub || tucked || poked;
+}
+const renderVehicle = async (ctx) => {
+    // A preview draws the one candidate GLB it was handed: there are no sealed renditions to walk.
+    if (ctx.preview)
+        return vehiclePass(ctx, { rendition: null, tier: null, measureOnly: false, modelCid: ctx.resolved.modelCid });
+    const started = Date.now();
+    const plan = renditionPlan(ctx.resolved.modelVariants ?? [], ctx.resolved.modelCid, ctx.resolved.root);
+    // Fail fast, before minutes of rendering, when the package would draw bytes the Version does not seal: the engine draws
+    // the tier's rendition artifactRef, not the manifest variant, so the run would judge another car under this name.
+    const unsealed = unsealedRenditionErrors(ctx.resolved.modelVariants ?? [], ctx.resolved.root, ctx.resolved.candidate?.vehiclePackage ?? null, ctx.resolved.identity.packageVersion ?? null);
+    if (unsealed.length) {
+        return {
+            route: 'test-grounds', url: '', frames: [], asserts: [], facts: { renditionsNotSealed: unsealed }, subjects: [{ id: ctx.resolved.identity.itemId, title: ctx.resolved.identity.title, role: 'host' }],
+            errors: unsealed, renderer: null, engineVersion: null, fetchedAssets: [],
+        };
+    }
+    const only = (process.env.HELIX_VQA_RENDITION_ONLY ?? '').trim();
+    const debugErrors = only ? [`HELIX_VQA_RENDITION_ONLY=${only} was set: a partial debug run, not for submission`] : [];
+    const tag = tagRendition;
+    const passes = [];
+    const runPass = async (spec) => {
+        const t0 = Date.now();
+        ctx.log('vehicle.rendition', { rendition: spec.rendition, tier: spec.tier ?? 'auto', measureOnly: spec.measureOnly });
+        const r = await vehiclePass(ctx, spec);
+        passes.push({
+            rendition: spec.rendition, tierThatSelectsIt: spec.tier, measureOnly: spec.measureOnly, modelCid: spec.modelCid, substitution: r.facts.substitution ?? null,
+            drawnTriangles: r.facts.drawnTriangles ?? null,
+            seconds: +((Date.now() - t0) / 1000).toFixed(1), modelFetched: (r.facts.modelFetchedFrom ?? []).length > 0,
+            contentFetched: r.facts.contentFetched ?? null, diagnosticFrame: r.facts.diagnosticFrame ?? null, errors: r.errors,
+            asserts: r.asserts.map((a) => ({ id: a.id, pass: a.pass, severity: a.severity })),
+        });
+        return r;
+    };
+    const def = plan.default;
+    const main = only && def && only !== def.id ? null : await runPass({ rendition: def?.id ?? null, tier: null, measureOnly: false, modelCid: ctx.resolved.modelCid });
+    const asserts = main ? tag(main.asserts, def?.id ?? null) : [];
+    const errors = [...debugErrors, ...(main?.errors ?? []), ...plan.errors];
+    const fetched = new Set(main?.fetchedAssets ?? []);
+    const extra = {};
+    const extraFrames = []; // the other renditions' evidence frames (they take no others)
+    const done = new Map();
+    if (main && def)
+        done.set((0, resolve_1.hexOf)(def.cid) ?? def.id, main);
+    for (const r of plan.others) {
+        if (only && only !== r.id)
+            continue;
+        const same = done.get((0, resolve_1.hexOf)(r.cid) ?? r.id);
+        if (same) {
+            // the same bytes as a rendition already measured: its measured asserts stand for this one too
+            asserts.push(...tag(same.asserts.filter((a) => exports.PER_RENDITION_ASSERT.test(a.id)), r.id));
+            passes.push({ rendition: r.id, sameBytesAs: same.facts.rendition ?? null, modelCid: r.cid });
+            continue;
+        }
+        const url = artifactUrl(ctx.resolved.root, r.id, r.cid, ctx.apiBase);
+        const res = await runPass({ rendition: r.id, tier: r.tier, measureOnly: true, modelCid: r.cid, substitute: def ? { fromCid: def.cid, toCid: r.cid, url } : null });
+        done.set((0, resolve_1.hexOf)(r.cid) ?? r.id, res);
+        asserts.push(...tag(res.asserts, r.id));
+        extraFrames.push(...res.frames);
+        errors.push(...res.errors.map((e) => `rendition ${r.id}: ${e}`));
+        for (const u of res.fetchedAssets)
+            fetched.add(u);
+        extra[r.id] = { wheels: res.facts.wheels, rideHeight: res.facts.rideHeight, occupants: res.facts.occupants, articulation: res.facts.articulation, timings: res.facts.timings, packageIdentity: res.facts.packageIdentity, runtimeEvidence: res.facts.runtimeEvidence };
+    }
+    const facts = { ...(main?.facts ?? {}), renditions: { default: def?.id ?? null, declared: plan.declared, passes, measured: extra }, renditionWallSeconds: +((Date.now() - started) / 1000).toFixed(1) };
+    return {
+        route: 'test-grounds', url: main?.url ?? '', frames: [...(main?.frames ?? []), ...extraFrames], asserts, facts,
+        subjects: main?.subjects ?? [{ id: ctx.resolved.identity.itemId, title: ctx.resolved.identity.title, role: 'host' }],
+        errors: [...new Set(errors)], renderer: main?.renderer ?? null, engineVersion: main?.engineVersion ?? null, fetchedAssets: [...fetched],
+    };
+};
+exports.renderVehicle = renderVehicle;
+/** Every assert of a pass carries the rendition it was measured on (none when the package declares no renditions). */
+function tagRendition(asserts, rendition) {
+    return rendition ? asserts.map((a) => ({ ...a, rendition })) : asserts;
+}
+/** The asserts measured on the drawn model (what a rendition can change); the rest are physics or input. */
+exports.PER_RENDITION_ASSERT = /^(vehicle\.wheels\.(at_hubs|arch_clearance|radius_matches_physics)|vehicle\.articulation\.|vehicle\.seats\.|vehicle\.occupants\.|scene\.|render\.|scale\.|frame\.)/;
+/** Where a rendition's sealed bytes live: its `mesh.visual.renditions[].artifactRef` (checked against the CID), else the
+ *  Continuum public object of that CID. */
+function artifactUrl(root, id, cid, apiBase) {
+    const hex = (0, resolve_1.hexOf)(cid) ?? '';
+    const rows = (root?.mesh?.visual?.renditions ?? []);
+    const row = rows.find((x) => x.id === id && typeof x.artifactRef === 'string' && (!x.checksumSha256 || x.checksumSha256 === hex))
+        ?? rows.find((x) => typeof x.artifactRef === 'string' && x.checksumSha256 === hex);
+    return row?.artifactRef ?? `${apiBase.replace(/\/$/, '')}/api/v1/continuum/public/objects/sha256:${hex}`;
+}
+/**
+ * The model renditions a vehicle package declares (manifest variants with a `vehicle.model.web.*` role). The default is
+ * the one the gate's model CID names (target-balanced); every other one is rendered through the tier that selects it,
+ * the tier with the richest interior when several do (a `minimal` tier hides the cabin).
+ */
+/** The sealed root's and the candidate vehicle package's renditions vs the Version's GLB variants (`vehicle/renditionManifest.ts`). */
+function unsealedRenditionErrors(variants, root, candidatePackage, version) {
+    const v = version ? `Version ${version}` : 'this Version';
+    const out = [];
+    const sealed = (0, renditionManifest_1.vehicleRenditionManifestProblems)(root, variants);
+    if (sealed.length)
+        out.push(`${v}'s sealed vehicle root draws bytes it does not seal, so owners would see another car: ${sealed.join('; ')} — ${renditionManifest_1.RENDITION_FIX}`);
+    const cand = candidatePackage ? (0, renditionManifest_1.vehicleRenditionManifestProblems)(candidatePackage, variants) : [];
+    if (cand.length)
+        out.push(`the --vehicle-package draws bytes ${v} does not seal: ${cand.join('; ')} — ${renditionManifest_1.RENDITION_FIX}`);
+    return out;
+}
+function renditionPlan(variants, defaultCid, root) {
+    const tiers = (root?.mesh?.visual?.tiers ?? {});
+    const rank = { full: 3, simplified: 2, hidden: 0 };
+    const order = ['medium', 'high', 'low', 'ultra', 'minimal'];
+    const tierFor = (id) => {
+        const c = Object.entries(tiers).filter(([, v]) => v?.renditionId === id).map(([k, v]) => ({ k, r: rank[String(v.interior)] ?? 1, o: order.indexOf(k) }));
+        c.sort((a, b) => b.r - a.r || (a.o < 0 ? 99 : a.o) - (b.o < 0 ? 99 : b.o));
+        return c[0]?.k ?? null;
+    };
+    const models = variants.filter((v) => /^vehicle\.model\.web(\.|$)/.test(v.role) && v.cid);
+    const declared = models.map((v) => ({ id: v.id, role: v.role, cid: v.cid, tier: tierFor(v.id) }));
+    const dhex = (0, resolve_1.hexOf)(defaultCid);
+    const def = declared.find((v) => (0, resolve_1.hexOf)(v.cid) === dhex) ?? null;
+    const errors = [];
+    if (models.length && !def)
+        errors.push(`the gate's model ${defaultCid ?? 'none'} is none of the declared model renditions (${models.map((m) => m.id).join(', ')})`);
+    return { default: def, others: declared.filter((v) => v !== def), declared, errors };
+}
+// ======================================================================================================================
+/** Wait for the world frame to present the vehicle, bailing early when the shell refuses the trial. */
+async function waitPresented(page, timeoutMs, fault = () => null) {
+    const t0 = Date.now();
+    const probe = () => {
+        const rows = globalThis.__assetGym?.mp?.portableVehicles?.presentationRows?.() ?? [];
+        return rows.length > 0 && rows[0].entity?.object3d?.children?.length > 0;
+    };
+    while (Date.now() - t0 < timeoutMs) {
+        for (const f of page.frames())
+            if (await f.evaluate(probe).catch(() => false))
+                return { frame: f, reason: 'presented' };
+        // A composition throw or an uncaught page error before presentation means the car will never appear: say so now,
+        // with the message, instead of waiting out the whole timeout. The reason says "refused", so the load is not retried.
+        const failure = fault();
+        if (failure)
+            return { frame: null, reason: failure };
+        const refusal = await page.evaluate(() => {
+            const t = (globalThis.document?.body?.innerText ?? '');
+            const m = /item trial unavailable[^\n]*\n?[^\n]*|can['’]t be tried[^\n]*|sign in to try[^\n]*/i.exec(t);
+            return m ? m[0].replace(/\s+/g, ' ').trim() : null;
+        }).catch(() => null);
+        if (refusal)
+            return { frame: null, reason: `Try Now refused: "${refusal}"` };
+        await sleep(750);
+    }
+    return { frame: null, reason: `timed out after ${Math.round(timeoutMs / 1000)} s` };
+}
+function engineVersionFrom(urls) {
+    for (const u of urls) {
+        const m = /\/humanoid-character\/runtime\/([^/]+)\/index\.js/.exec(u) ?? /\/packages\/[^/]+\/([0-9][^/]*)\/code\/index\.js/.exec(u);
+        if (m)
+            return decodeURIComponent(m[1]);
+    }
+    return null;
+}
+async function hideOverlays(page) {
+    for (const f of page.frames())
+        await f.evaluate(vehicleProbe_1.HIDE_OVERLAYS).catch(() => undefined);
+}
+/** Wheel table from a pull: drawn geometry, physics hub, arch + penetration, ride height. */
+function buildWheelRows(pull) {
+    const carX = pull.wheels.length ? pull.wheels.reduce((s, w) => s + (w.nodePos?.[0] ?? w.mount[0]), 0) / pull.wheels.length : 0;
+    // move each drawn wheel (and its physics hub) from the pull instant to the median compression of the window
+    const shiftY = pull.wheels.map((w, i) => {
+        const med = pull.compressionWindow?.[i]?.median;
+        return med !== null && med !== undefined && w.compression !== null ? med - w.compression : 0;
+    });
+    const geos = pull.wheels.map((w, i) => {
+        if (!w.axleNode)
+            return null;
+        const pts = shiftY[i] ? w.points.map((v, k) => (k % 3 === 1 ? v + shiftY[i] : v)) : w.points;
+        return (0, vehicleMath_1.wheelGeometry)(pts, w.axleNode);
+    });
+    const plane = (0, vehicleMath_1.contactPlane)(geos.map((g, i) => (g ? { centre: g.centre, radius: g.radius, axle: g.axle } : null)).filter((x) => !!x)
+        .concat(geos.every((g) => !g) ? pull.wheels.map((w) => ({ centre: w.nodePos ?? w.mount, radius: w.radius, axle: [1, 0, 0] })) : []));
+    const ride = (0, vehicleMath_1.rideHeight)(pull.body, plane);
+    const rows = pull.wheels.map((w, i) => {
+        const g = geos[i];
+        const comp = (w.compression ?? 0) + shiftY[i];
+        const hub = [w.mount[0], w.mount[1] - ((w.restLength ?? 0) - comp), w.mount[2]];
+        const outward = g ? (Math.sign(g.axle[0] * (g.centre[0] - carX)) || 1) : 1;
+        // judged on the body SURFACE around the wheel (triangle samples), not only its vertices
+        const arch = g ? (0, vehicleMath_1.archAnalysis)((0, vehicleMath_1.sampleTriangles)(pull.bodyTris, (0, vehicleMath_1.wheelNeighbourhood)(g)), g, outward) : null;
+        const contactY = g ? g.centre[1] - g.radius : null;
+        const local = g ? (0, vehicleMath_1.rideHeight)(pull.body, [contactY, 0, 0], (p) => Math.abs(p[2] - g.centre[2]) < 0.6 && Math.sign(p[0] - carX) === Math.sign(g.centre[0] - carX)) : null;
+        return {
+            id: w.id, hub: hub.map((v) => rd(v, 10000)), node: w.nodePos ? w.nodePos.map((v) => rd(v, 10000)) : null,
+            drawnCentre: g ? g.centre : null, delta: g ? (0, vehicleMath_1.sub)(g.centre, hub).map((v) => rd(v, 10000)) : null,
+            radius: g ? g.radius : null, physicsRadius: w.radius, rollRadius: (0, vehicleClearance_1.wheelRollingRadius)({ radius: w.radius, axle: w.axle ?? null }, pull.tyreByAxle ?? null), axle: w.axle ?? null, width: g ? g.width : null, axleAgreementDeg: g ? g.axleAgreementDeg : null,
+            meshes: w.meshes, penetrationCount: arch?.penetrationCount ?? null, maxPenetrationM: arch?.maxPenetrationM ?? null, penetrationMeshes: arch?.penetrationMeshes ?? [],
+            archGapM: arch?.archGapM ?? null, archGapTopM: arch?.archGapTopM ?? null, archCutoutTopM: arch?.archCutoutTopM ?? null, archGapAtDeg: arch?.archGapAtDeg ?? null, archGapMesh: arch?.archGapMesh ?? null,
+            rideHeightLocalM: local?.minM ?? null,
+            compression: rd(comp, 10000), compressionWindow: pull.compressionWindow?.[i] ?? null,
+        };
+    });
+    const duplicates = [];
+    for (const s of pull.strays) {
+        if (!s.centre)
+            continue;
+        for (const r of rows) {
+            const c = r.drawnCentre ?? r.hub;
+            const d = (0, vehicleMath_1.len)((0, vehicleMath_1.sub)(s.centre, c));
+            if (d < vehicleMath_1.VEHICLE_QA_THRESHOLDS.duplicateHubM)
+                duplicates.push({ mesh: s.mesh, nearWheel: r.id, distM: rd(d, 1000) });
+        }
+    }
+    return { rows, duplicates, ride, plane: plane.map((v) => rd(v, 10000)) };
+}
+/**
+ * Board the driver seat with the real E key.
+ *
+ * Why not just teleport next to the door: the room's movement-plausibility gate (helix-colyseus-server
+ * `MAX_SPEED_MPS` = 60 m/s per accepted frame) rejects a 16 m client-side jump and snaps the avatar back to the
+ * spawn a moment later. The seat request is judged by the SERVER, so E pressed in that window is refused, and
+ * `wouldBoard` reads null once the snap-back lands. Measured 2026-10-02: 1 of 4 loads boarded on the first try
+ * that way. So the avatar WALKS there in plausible steps (≈8 m/s), stands still until its position holds, and only
+ * then presses E — and each failed attempt is diagnosed (snapped back / out of reach / refused) in the trace.
+ */
+async function boardDriver(page, frame, driverSeat) {
+    const ready = await pollFrame(frame, `(() => Array.isArray(globalThis.__assetGym?.mp?.seatEvidence?.()?.local?.atWorld))()`, 30_000);
+    if (!ready)
+        return { ok: false, reason: 'seat evidence never became available', tries: 0 };
+    // stand outside the driver's door: the driver seat's lateral side, 1.7 m from the centreline
+    const seat = await frame.evaluate((name) => {
+        const P = globalThis.__vqaVeh;
+        const r = P.root();
+        r.updateMatrixWorld(true);
+        let o = null;
+        // by the manifest key when it names a node, else by the driver's cabin seat id (a legacy "driver" key names no node)
+        r.traverse((x) => { if (!o && name && x.name === name && !x.isMesh)
+            o = x; });
+        if (!o)
+            r.traverse((x) => { if (!o && x.name === 'seat_dside_f' && !x.isMesh)
+                o = x; });
+        return o ? P.bodyPos(o) : null;
+    }, driverSeat);
+    const side = seat ? (Math.sign(seat[0]) || 1) : 1;
+    const local = [side * 1.7, 0, seat ? seat[2] : 0.2];
+    const read = () => frame.evaluate(() => {
+        const l = globalThis.__assetGym.mp.seatEvidence().local;
+        const d = (l?.seats ?? []).find((x) => x.role === 'driver');
+        return { at: l?.atWorld ?? null, would: l?.wouldBoard?.role ?? null, seated: l?.seated ? { seatId: l.seated.seatId, role: l.seated.role } : null, driverDist: d?.distanceM ?? null, refusal: d?.refusal ?? null };
+    });
+    // walk in steps the movement gate believes; returns the target in world space
+    const walk = () => frame.evaluate(async (l) => {
+        const mp = globalThis.__assetGym.mp;
+        const e = mp.portableVehicles.presentationRows()[0].entity;
+        const tgt = e.object3d.localToWorld(new e.object3d.position.constructor(...l));
+        const from = mp.seatEvidence().local.atWorld;
+        const y = from[1] + 0.05;
+        const dist = Math.hypot(tgt.x - from[0], tgt.z - from[2]);
+        const n = Math.max(1, Math.ceil(dist / 0.4));
+        for (let i = 1; i <= n; i++) {
+            const k = i / n;
+            mp.local.services.body.teleport({ x: from[0] + (tgt.x - from[0]) * k, y, z: from[2] + (tgt.z - from[2]) * k });
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return [tgt.x, y, tgt.z];
+    }, local);
+    const t0 = Date.now();
+    const trace = [];
+    let last = await read();
+    let tries = 0;
+    for (let i = 0; i < 6 && !last.seated; i++) {
+        tries = i + 1;
+        const tgt = await walk();
+        // hold still until the server has accepted the position (no snap-back for 1 s)
+        let held = 0;
+        for (let k = 0; k < 12 && held < 3; k++) {
+            await sleep(350);
+            last = await read();
+            const off = last.at ? Math.hypot(last.at[0] - tgt[0], last.at[2] - tgt[2]) : Infinity;
+            held = off < 0.6 ? held + 1 : 0;
+            if (off > 3)
+                break; // snapped back: walk again
+        }
+        const rec = { t: +((Date.now() - t0) / 1000).toFixed(1), held, at: last.at?.map((v) => +v.toFixed(2)), would: last.would, driverDist: last.driverDist === null ? null : +last.driverDist.toFixed(2), refusal: last.refusal };
+        if (held < 3 || last.would !== 'driver') {
+            rec.outcome = held < 3 ? 'position not held (server snap-back)' : `would board ${last.would ?? 'nothing'}`;
+            trace.push(rec);
+            continue;
+        }
+        await page.keyboard.press('KeyE');
+        for (let k = 0; k < 12 && !last.seated; k++) {
+            await sleep(250);
+            last = await read();
+        }
+        rec.outcome = last.seated ? `seated ${last.seated.role}` : 'E pressed, not seated';
+        trace.push(rec);
+    }
+    if (!last.seated)
+        return { ok: false, reason: `not seated after ${tries} walk-and-board attempts (last: ${JSON.stringify(trace[trace.length - 1] ?? null)})`, tries, trace };
+    if (last.seated.role !== 'driver')
+        return { ok: false, reason: `seated as ${last.seated.role}, not driver`, seated: last.seated, tries, trace };
+    return { ok: true, reason: 'seated', seated: last.seated, tries, trace };
+}
+async function pollFrame(frame, src, timeoutMs, stepMs = 400) {
+    const t0 = Date.now();
+    while (Date.now() - t0 < timeoutMs) {
+        if (await frame.evaluate(src).catch(() => false))
+            return true;
+        await sleep(stepMs);
+    }
+    return false;
+}
+/** All wheels grounded and the body still (position drift < 5 mm over 600 ms). */
+async function waitSettled(frame, timeoutMs) {
+    const t0 = Date.now();
+    const read = () => frame.evaluate(() => { const s = globalThis.__vqaVeh.e().controller.getState(); return { g: (s.wheels ?? []).map((w) => !!w.grounded), p: [s.position.x, s.position.y, s.position.z], speed: s.speed }; });
+    let prev = await read();
+    let last = prev;
+    while (Date.now() - t0 < timeoutMs) {
+        await sleep(600);
+        last = await read();
+        const drift = Math.hypot(last.p[0] - prev.p[0], last.p[1] - prev.p[1], last.p[2] - prev.p[2]);
+        const grounded = last.g.length > 0 && last.g.every(Boolean);
+        if (grounded && drift < 0.005)
+            return { grounded: true, still: true, seconds: (Date.now() - t0) / 1000, last };
+        prev = last;
+    }
+    return { grounded: last.g.length > 0 && last.g.every(Boolean), still: false, seconds: (Date.now() - t0) / 1000, last };
+}
+async function setCameraMode(page, frame, want) {
+    const mode = () => frame.evaluate(() => globalThis.__assetGym.mp.local.services.camera?.mode ?? null).catch(() => null);
+    let m = await mode();
+    let presses = 0;
+    for (; presses < 4 && m !== want; presses++) {
+        await page.keyboard.press('KeyT');
+        await page.waitForTimeout(700);
+        m = await mode();
+    }
+    return { mode: m, presses };
+}
+async function sweepPanel(page, frame, p, car, shot, setCam) {
+    const main = p.nodes[0];
+    const angleNow = async (closedQ) => {
+        const pose = await frame.evaluate((n) => globalThis.__vqaVeh.pose([n]), main);
+        return pose[main] ? (0, vehicleMath_1.signedAngleAboutDeg)(closedQ, pose[main].q, p.hinge.axis) : null;
+    };
+    const durable = () => frame.evaluate((s) => globalThis.__vqaVeh.durable()[s], p.signal);
+    const rels = () => frame.evaluate((nodes) => Object.fromEntries(nodes.slice(1).map((n) => [n, globalThis.__vqaVeh.rel(nodes[0], n)])), p.nodes);
+    const closedPose = await frame.evaluate((n) => globalThis.__vqaVeh.pose([n]), main);
+    if (!closedPose[main])
+        throw new Error(`panel node ${main} not found in the scene`);
+    const closedQ = closedPose[main].q;
+    const closedDurable = await durable();
+    const closedRel = await rels();
+    const box = await frame.evaluate((n) => globalThis.__vqaVeh.nodeBox(n), p.nodes);
+    /**
+     * Follow the panel until its travel finishes, never on a fixed sleep (lids and physical doors run slower on a
+     * loaded machine). Re-issues the toggle when the runtime's own state never changed and nothing moved, and reports
+     * WHY it stopped: reached the target, stopped short / never moved although the runtime state flipped (a runtime
+     * defect), or the toggle was never accepted.
+     */
+    const travel = async (target, tol, want, toggle) => {
+        const start = await angleNow(closedQ);
+        const t0 = Date.now();
+        const trace = [];
+        let prev = start, stable = 0, reissued = 0, lastToggleAt = t0, a = start, d = undefined;
+        while (Date.now() - t0 < 9000) {
+            await sleep(150);
+            a = await angleNow(closedQ);
+            d = await durable();
+            const t = +((Date.now() - t0) / 1000).toFixed(2);
+            if (trace.length < 60)
+                trace.push([t, a === null ? null : +a.toFixed(1)]);
+            if (a !== null && prev !== null && Math.abs(a - prev) < 0.25)
+                stable++;
+            else
+                stable = 0;
+            prev = a;
+            const moved = a !== null && start !== null ? Math.abs(a - start) : 0;
+            if (a !== null && Math.abs(a - target) <= tol && stable >= 2)
+                return { deg: a, status: 'reached', reissued, seconds: t, trace };
+            if (toggle && typeof d === 'boolean' && d !== want && moved < 2 && Date.now() - lastToggleAt > 1500 && reissued < 2) {
+                await toggle();
+                reissued++;
+                lastToggleAt = Date.now();
+            }
+            if (moved >= 2 && stable >= 16)
+                break; // moved, then sat still for 2.4 s away from the target
+        }
+        const moved = a !== null && start !== null ? Math.abs(a - start) : 0;
+        const status = typeof d === 'boolean' && d !== want ? 'toggle-not-accepted' : moved < 2 ? 'state-flipped-but-panel-did-not-move' : 'stopped-short';
+        return { deg: a, status, reissued, seconds: +((Date.now() - t0) / 1000).toFixed(2), trace };
+    };
+    // operate with the default key, verified by the durable flip; otherwise discover the key among the free ones
+    let key = PANEL_KEYS[p.signal] ?? PANEL_KEYS[p.id] ?? null;
+    const tried = [];
+    const press = async (k) => { await page.keyboard.press(k); tried.push(k); };
+    let flipped = false;
+    // The runtime's durable state can lag the key by several hundred ms (measured: a trunk flip landed after 350 ms,
+    // was credited to the NEXT fallback key, and that key — the driver door — was then pressed to "close" the trunk).
+    // So each candidate gets up to 1.5 s, and counts as accepted on the state flip OR on the panel starting to move.
+    for (const k of [key, ...FALLBACK_KEYS.filter((x) => x !== key)].filter((x) => !!x)) {
+        const before = await frame.evaluate(() => globalThis.__vqaVeh.durable());
+        await press(k);
+        let after = before;
+        let movedNow = false;
+        for (let w = 0; w < 10; w++) {
+            await sleep(150);
+            after = await frame.evaluate(() => globalThis.__vqaVeh.durable());
+            const a = await angleNow(closedQ);
+            movedNow = a !== null && Math.abs(a) > 2;
+            if (after[p.signal] !== before[p.signal] || movedNow)
+                break;
+            if (Object.keys(after).some((x) => x !== p.signal && after[x] !== before[x]))
+                break;
+        }
+        if (after[p.signal] !== before[p.signal] || movedNow) {
+            key = k;
+            flipped = true;
+            break;
+        }
+        // the key toggled some OTHER panel: put it back and wait for it to settle before trying the next key
+        const other = Object.keys(after).find((x) => after[x] !== before[x] && /^(door|hood|trunk|boot|bonnet|tailgate|lid)/i.test(x));
+        if (other) {
+            await page.keyboard.press(k);
+            await sleep(1800);
+        }
+        if (tried.length >= 4)
+            break;
+    }
+    const expected = p.hinge.openDeg - p.hinge.closedDeg;
+    const opening = await travel(expected, vehicleMath_1.VEHICLE_QA_THRESHOLDS.panelTolDeg, true, flipped && key ? () => page.keyboard.press(key) : null);
+    const openDeg = opening.deg;
+    const openDurable = await durable();
+    const openRel = await rels();
+    // frame the panel at full open: from outside, on the panel's side, a little above
+    if (box) {
+        const c = [(box.min[0] + box.max[0]) / 2, (box.min[1] + box.max[1]) / 2, (box.min[2] + box.max[2]) / 2];
+        const carC = [(car.min[0] + car.max[0]) / 2, (car.min[1] + car.max[1]) / 2, (car.min[2] + car.max[2]) / 2];
+        const isLid = Math.abs(p.hinge.axis[0]) > 0.7;
+        const dir = isLid ? [0.7, 0.9, Math.sign(c[2] - carC[2]) || 1] : [Math.sign(c[0] - carC[0]) || 1, 0.45, 0.9];
+        const pad = 0.5;
+        await setCam((0, vehicleMath_1.camFit)([box.min[0] - pad, box.min[1] - pad * 0.4, box.min[2] - pad], [box.max[0] + pad, box.max[1] + pad * 0.6, box.max[2] + pad], dir, 38, 1.6, 0.9));
+    }
+    await shot(`${p.id}.open`, `${p.id} (${p.role || 'panel'}) at full open — declared ${p.hinge.openDeg}°, measured ${openDeg === null ? '?' : openDeg.toFixed(1)}°`, 'articulation', 350);
+    let closing = null;
+    if (flipped && key) {
+        await page.keyboard.press(key);
+        closing = await travel(0, vehicleMath_1.VEHICLE_QA_THRESHOLDS.panelReturnTolDeg, false, () => page.keyboard.press(key));
+    }
+    const closedAgainDeg = closing ? closing.deg : await angleNow(closedQ);
+    const againDurable = await durable();
+    const attached = Object.keys(closedRel).map((n) => {
+        const a = closedRel[n], o = openRel[n];
+        if (!a || !o)
+            return { node: n, missing: true };
+        const maxPos = Math.max(...a.p.map((v, i) => Math.abs(o.p[i] - v)));
+        const qd = Math.abs(a.q.reduce((s, v, i) => s + v * o.q[i], 0));
+        return { node: n, maxPosDeltaM: rd(maxPos, 10000), quatDot: rd(qd, 100000) };
+    });
+    return {
+        id: p.id, expectedDeg: p.hinge.openDeg - p.hinge.closedDeg,
+        openDeg: openDeg === null ? null : +openDeg.toFixed(2), closedAgainDeg: closedAgainDeg === null ? null : +closedAgainDeg.toFixed(2),
+        durable: { closed: closedDurable, open: openDurable, closedAgain: againDurable }, attached, key: flipped ? key : null,
+        opening: { status: flipped ? opening.status : 'no key toggled this panel', reissued: opening.reissued, seconds: opening.seconds, trace: opening.trace },
+        closing: closing ? { status: closing.status, reissued: closing.reissued, seconds: closing.seconds, trace: closing.trace } : null,
+    };
+}
+async function steeringSweep(page, frame, rows, shot, setCam, clearCam) {
+    const read = () => frame.evaluate(() => globalThis.__vqaVeh.steering());
+    const centre = await read();
+    const front = rows.find((r) => /lf|fl|front_?l/i.test(r.id)) ?? rows[0];
+    const fc = front.drawnCentre ?? front.hub;
+    const fr = front.radius ?? front.physicsRadius;
+    await page.keyboard.down('KeyA');
+    await page.waitForTimeout(1100);
+    const lock = await read();
+    // the turned front wheel: from ahead and outside, low
+    const out = Math.sign(fc[0]) || 1;
+    await setCam({ pos: [fc[0] + out * 1.25, fc[1] + 0.35, fc[2] + 1.35], target: [fc[0], fc[1] + fr * 0.2, fc[2]], fov: 38, near: 0.05 });
+    await shot('steering.full_lock', `Full lock (A held): ${front.id} turned`, 'steering', 300);
+    await clearCam();
+    const fp = await setCameraMode(page, frame, 'first-person');
+    await page.waitForTimeout(500);
+    await shot('steering.full_lock.cabin', 'Full lock (A held): steering wheel, driver view', 'steering', 400);
+    const lock2 = await read();
+    await page.keyboard.up('KeyA');
+    await setCameraMode(page, frame, 'third-person');
+    await page.waitForTimeout(800);
+    const wheels = centre.wheels.map((w, i) => {
+        const l = lock.wheels[i];
+        const yaw0 = w.axle ? (0, vehicleMath_1.axleYawDeg)(w.axle) : null, yaw1 = l?.axle ? (0, vehicleMath_1.axleYawDeg)(l.axle) : null;
+        return { id: w.id, steered: w.steered, drawnYawDeg: yaw0 !== null && yaw1 !== null ? +(yaw1 - yaw0).toFixed(2) : null, physicsSteerDeg: l?.physicsSteerRad !== null && l?.physicsSteerRad !== undefined ? +((l.physicsSteerRad * 180) / Math.PI).toFixed(2) : null };
+    });
+    const rimDeg = centre.rimQ && lock.rimQ ? +(0, vehicleMath_1.qAngleDeg)((0, vehicleMath_1.qMul)(lock.rimQ, (0, vehicleMath_1.qInv)(centre.rimQ))).toFixed(1) : null;
+    const steered = wheels.filter((w) => w.steered);
+    const weak = steered.filter((w) => w.drawnYawDeg === null || Math.abs(w.drawnYawDeg) < vehicleMath_1.VEHICLE_QA_THRESHOLDS.steerWheelMinDeg);
+    const disagree = steered.filter((w) => w.drawnYawDeg !== null && w.physicsSteerDeg !== null && Math.abs(Math.abs(w.drawnYawDeg) - Math.abs(w.physicsSteerDeg)) > vehicleMath_1.VEHICLE_QA_THRESHOLDS.steerAgreementTolDeg);
+    const rimOk = rimDeg !== null && rimDeg >= vehicleMath_1.VEHICLE_QA_THRESHOLDS.steeringWheelMinDeg;
+    const pass = steered.length > 0 && weak.length === 0 && disagree.length === 0 && rimOk;
+    const detail = !steered.length ? 'no steered wheels in the live tuning'
+        : weak.length ? `front wheels barely turn at full lock: ${weak.map((w) => `${w.id} ${w.drawnYawDeg}°`).join(', ')}`
+            : disagree.length ? `drawn wheel yaw disagrees with physics steer: ${disagree.map((w) => `${w.id} drawn ${w.drawnYawDeg}° vs ${w.physicsSteerDeg}°`).join(', ')}`
+                : !rimOk ? `steering wheel ${centre.rimNode ?? '(none)'} turned only ${rimDeg ?? '?'}° at full lock`
+                    : `full lock: ${steered.map((w) => `${w.id} ${w.drawnYawDeg}°`).join(', ')}; steering wheel ${rimDeg}°`;
+    return { pass, detail, measured: { wheels, steeringWheelDeg: rimDeg, rimNode: centre.rimNode, rimAngleRad: { centre: centre.rimAngleRad, lock: lock.rimAngleRad, lockFirstPerson: lock2.rimAngleRad }, steerInput: lock.steerInput, cameraForCabin: fp } };
+}
+/** Scenery boxes around the car (WORLD frame) and the car's body->world matrix, read once per decision. */
+async function readScenery(frame) {
+    return frame.evaluate((r) => globalThis.__vqaVeh.sceneBoxes(r), 60).catch(() => null);
+}
+/**
+ * Clear distance from the car's bumper (front for dir +1, rear for -1) along its own heading to the first scenery box,
+ * sampled from five points across the bumper face at two heights. Infinity when the grounds report nothing there.
+ */
+function bumperClearance(sc, bounds, dirSign) {
+    const z = dirSign > 0 ? bounds.max[2] : bounds.min[2];
+    const w = (bounds.max[0] - bounds.min[0]) / 2 * 0.85;
+    const cx = (bounds.max[0] + bounds.min[0]) / 2;
+    const lo = bounds.min[1] + Math.min(0.25, (bounds.max[1] - bounds.min[1]) * 0.25);
+    const hi = bounds.min[1] + (bounds.max[1] - bounds.min[1]) * 0.6;
+    const origins = [];
+    for (const y of [lo, hi])
+        for (const x of [cx - w, cx - w / 2, cx, cx + w / 2, cx + w])
+            origins.push((0, vehicleClearance_1.applyMatrix)(sc.bodyToWorld, [x, y, z]));
+    const o0 = (0, vehicleClearance_1.applyMatrix)(sc.bodyToWorld, [0, 0, 0]);
+    const o1 = (0, vehicleClearance_1.applyMatrix)(sc.bodyToWorld, [0, 0, dirSign]);
+    const d = [o1[0] - o0[0], 0, o1[2] - o0[2]];
+    const l = Math.hypot(d[0], d[2]) || 1;
+    return (0, vehicleClearance_1.clearanceAlong)(origins, [d[0] / l, 0, d[2] / l], sc.boxes);
+}
+/**
+ * The drive. Plans against the test grounds' own scenery so it never ends against a wall (F40 round 1: it did, and every
+ * body-frame exterior camera after it was then inside the wall): it measures the clear room behind and ahead, backs up
+ * no further than that room allows, releases the throttle early enough to settle, coast and still stop `marginM` short
+ * of what is ahead, samples the spin once launch wheelspin has died away and only over the free part of the coast, and
+ * finally drives back to where it started (closed loop on position, bounded time), so the occupant phase has the space
+ * the car was spawned in. Stops use the foot brake (the opposite pedal, as a player does) with the handbrake.
+ */
+async function driveAndSample(page, frame, rows, shot, clearCam, bounds) {
+    await clearCam();
+    const C = vehicleClearance_1.CLEARANCE_DEFAULTS;
+    const radii = rows.map((r) => r.rollRadius ?? r.physicsRadius);
+    // position (world xz), forward speed, the car's forward direction (world xz) and each wheel's angular velocity
+    const state = () => frame.evaluate(() => {
+        const P = globalThis.__vqaVeh;
+        const e = P.e();
+        const s = e.controller.getState();
+        const r = P.root();
+        const V = P.V();
+        r.updateMatrixWorld(true);
+        const a = r.localToWorld(new V(0, 0, 0));
+        const b = r.localToWorld(new V(0, 0, 1));
+        // every non-finite number in the vehicle state and its telemetry (a NaN froze the R34 in Try Now)
+        const nf = [];
+        const walk = (v, at, d) => {
+            if (nf.length >= 12 || d > 4)
+                return;
+            if (typeof v === 'number') {
+                if (!Number.isFinite(v))
+                    nf.push(`${at}=${v}`);
+                return;
+            }
+            if (!v || typeof v !== 'object')
+                return;
+            if (Array.isArray(v)) {
+                v.slice(0, 32).forEach((x, i) => walk(x, `${at}[${i}]`, d + 1));
+                return;
+            }
+            for (const k of Object.keys(v).slice(0, 64))
+                walk(v[k], at ? `${at}.${k}` : k, d + 1);
+        };
+        walk(s, 'state', 0);
+        try {
+            if (typeof e.telemetry === 'function')
+                walk(e.telemetry(), 'telemetry', 0);
+        }
+        catch { /* telemetry is optional */ }
+        return { fwd: s.forwardSpeed, gear: s.gear, p: [s.position.x, s.position.z], h: [b.x - a.x, b.z - a.z], w: (s.wheels || []).map((w) => (typeof w.angularVelocity === 'number' ? w.angularVelocity : null)), nf };
+    });
+    // the World's audio graph as the drive sees it (browser.ts installHooks records contexts and non-finite AudioParam writes)
+    const audioNow = () => frame.evaluate(() => {
+        const A = globalThis.__vqaAudio;
+        let issues = [];
+        let fitted = [];
+        try {
+            const au = globalThis.__assetGym?.mp?.portableVehicleEvidence?.().vehicles?.[0]?.audio;
+            issues = ((au?.issues) ?? []).map((i) => String(i?.reason ?? i));
+            fitted = ((au?.fittedRows) ?? []).map((r) => `${r.id}${r.slot ? `:${r.slot}` : ''}`);
+        }
+        catch { /* evidence is optional */ }
+        return { ctx: (A?.contexts ?? []).map((c) => ({ state: String(c.state), time: Number(c.currentTime) })), n: Number(A?.nonFiniteCount ?? 0), w: Number(A?.writes ?? 0), ex: (A?.nonFinite ?? []).slice(0, 5), issues, fitted };
+    }).catch(() => ({ ctx: [], n: 0, w: 0, ex: [], issues: [], fitted: [] }));
+    const pageErrors = [];
+    let watchErrors = false;
+    const onPageError = (err) => { if (watchErrors && pageErrors.length < 10)
+        pageErrors.push(String(err?.message ?? err).slice(0, 300)); };
+    const onConsole = (m) => { if (m.type() === 'error' && /non-finite|setValueAtTime|AudioParam|\bNaN\b/i.test(m.text()) && pageErrors.length < 10)
+        pageErrors.push(m.text().slice(0, 300)); };
+    page.on('pageerror', onPageError);
+    page.on('console', onConsole);
+    try {
+        const brakeTo0 = async () => {
+            // the foot brake is the pedal against the motion (S going forward, W going backwards), with the handbrake
+            for (let i = 0; i < 40; i++) {
+                const s = await state();
+                if (Math.abs(s.fwd) < 0.3)
+                    break;
+                const key = s.fwd > 0 ? 'KeyS' : 'KeyW';
+                await page.keyboard.down(key);
+                await page.keyboard.down('Space');
+                await page.waitForTimeout(100);
+                await page.keyboard.up(key);
+                await page.keyboard.up('Space');
+            }
+        };
+        const trace = [];
+        const short = (s) => ({ fwd: +s.fwd.toFixed(2), gear: s.gear, p: s.p.map((v) => +v.toFixed(3)) });
+        const p0 = await state();
+        const hl = Math.hypot(p0.h[0], p0.h[1]) || 1;
+        const heading = [p0.h[0] / hl, p0.h[1] / hl];
+        /** Displacement from the start along the START heading (+ = ahead of it), and across it. */
+        const along = (p) => (p[0] - p0.p[0]) * heading[0] + (p[1] - p0.p[1]) * heading[1];
+        const across = (p) => -(p[0] - p0.p[0]) * heading[1] + (p[1] - p0.p[1]) * heading[0];
+        const room = async () => {
+            const sc = bounds ? await readScenery(frame) : null;
+            if (!sc || !bounds)
+                return { ahead: { distanceM: Infinity, box: null, skipped: 0 }, behind: { distanceM: Infinity, box: null, skipped: 0 }, boxes: 0 };
+            return { ahead: bumperClearance(sc, bounds, 1), behind: bumperClearance(sc, bounds, -1), boxes: sc.boxes.length };
+        };
+        const fin = (v) => (Number.isFinite(v) ? +v.toFixed(2) : null);
+        const room0 = await room();
+        trace.push({ phase: 'start', ...short(p0), clearAheadM: fin(room0.ahead.distanceM), clearAheadBox: room0.ahead.box, clearBehindM: fin(room0.behind.distanceM), clearBehindBox: room0.behind.box, sceneryBoxes: room0.boxes });
+        // 1. back up to make room ahead: up to REVERSE_WANT_M, never closer than the margin to what is behind
+        // Use the room behind (bounded by it, minus the margin): the coast needs its whole window at speed.
+        const REVERSE_WANT_M = 20;
+        {
+            const t0 = Date.now();
+            await page.keyboard.down('KeyS');
+            for (;;) {
+                await page.waitForTimeout(80);
+                const s = await state();
+                if (Date.now() - t0 > 5000 || (0, vehicleClearance_1.shouldStopReversing)({ travelledM: Math.max(0, -along(s.p)), speedMps: s.fwd, clearM: room0.behind.distanceM, wantM: REVERSE_WANT_M }))
+                    break;
+            }
+            await page.keyboard.up('KeyS');
+        }
+        trace.push({ phase: 'reversed', ...short(await state()) });
+        await brakeTo0();
+        await page.waitForTimeout(300);
+        // 2. throttle, released early enough to settle, coast and still stop short of what is ahead
+        const room1 = await room();
+        const s1 = await state();
+        const from = along(s1.p);
+        trace.push({ phase: 'stopped', ...short(s1), alongM: +from.toFixed(2), clearAheadM: fin(room1.ahead.distanceM), clearAheadBox: room1.ahead.box });
+        // Throttle with the driver's own traction control: a powerful car spins its driven wheels from rest, and a wheel
+        // released spinning keeps pushing the car on (measured: the F40 went from 6.7 to 8.2 m/s AFTER the release), so W is
+        // lifted while any wheel slips more than TC_SLIP and pressed again once it grips.
+        const TC_SLIP = 0.25;
+        let wDown = false;
+        const setW = async (down) => { if (down === wDown)
+            return; if (down)
+            await page.keyboard.down('KeyW');
+        else
+            await page.keyboard.up('KeyW'); wDown = down; };
+        const audio0 = await audioNow();
+        watchErrors = true;
+        // Debug proof only (the caller records a harness error): from the throttle on, every AudioParam write carries NaN.
+        if (process.env.HELIX_VQA_FAULT_AUDIO_NAN)
+            await frame.evaluate(() => { const A = globalThis.__vqaAudio; if (A)
+                A.injectNaN = true; });
+        await setW(true);
+        let peak = 0;
+        let releasedFor = 'speed';
+        let tcLifts = 0;
+        const t0 = Date.now();
+        const alive = [];
+        for (;;) {
+            await page.waitForTimeout(40);
+            const s = await state();
+            alive.push({ t: (Date.now() - t0) / 1000, fwd: s.fwd, p: s.p, w: s.w, nonFinite: s.nf });
+            if (s.nf.length && Date.now() - t0 > 1500) {
+                releasedFor = 'non-finite state';
+                break;
+            }
+            peak = Math.max(peak, Number.isFinite(s.fwd) ? s.fwd : 0);
+            if (s.fwd > 9)
+                break;
+            if (Date.now() - t0 > 4000) {
+                releasedFor = 'time';
+                break;
+            }
+            if ((0, vehicleClearance_1.shouldRelease)({ travelledM: along(s.p) - from, speedMps: s.fwd, clearM: room1.ahead.distanceM })) {
+                releasedFor = 'room';
+                break;
+            }
+            const slip = (0, vehicleClearance_1.worstSlip)(s.fwd, s.w, radii);
+            if (slip !== null && slip > TC_SLIP) {
+                if (wDown)
+                    tcLifts++;
+                await setW(false);
+            }
+            else
+                await setW(true);
+        }
+        await setW(false);
+        const throttleSeconds = (Date.now() - t0) / 1000;
+        watchErrors = false;
+        if (process.env.HELIX_VQA_FAULT_AUDIO_NAN)
+            await frame.evaluate(() => { const A = globalThis.__vqaAudio; if (A)
+                A.injectNaN = false; }).catch(() => undefined);
+        const audio1 = await audioNow();
+        const aliveFacts = {
+            throttleSeconds, samples: alive, pageErrors: [...pageErrors],
+            audio: { before: audio0.ctx, after: audio1.ctx, nonFiniteWrites: Math.max(0, audio1.n - audio0.n), nonFiniteExamples: audio1.ex.map((x) => ({ method: String(x.method), value: String(x.value) })), issues: audio1.issues, fittedSoundRows: audio1.fitted, paramWrites: Math.max(0, audio1.w - audio0.w) },
+        };
+        const sr = await state();
+        trace.push({ phase: 'throttle-released', releasedFor, tractionLifts: tcLifts, ...short(sr), travelledM: +(along(sr.p) - from).toFixed(2), slip: (0, vehicleClearance_1.worstSlip)(sr.fwd, sr.w, radii) });
+        // The coast is sampled once every wheel rolls with the road (bounded wait; the traction control above keeps it short).
+        const tr = Date.now();
+        {
+            let slip = null;
+            for (;;) {
+                const s = await state();
+                slip = (0, vehicleClearance_1.worstSlip)(s.fwd, s.w, radii);
+                if (slip === null || slip < C.slipSettledFraction || Date.now() - tr > C.slipSettleMaxS * 1000)
+                    break;
+                // no brake here: a dab of the foot brake locks a wheel (measured on the F40: slip 1.0 and 6.0 -> 2.4 m/s)
+                await page.waitForTimeout(30);
+            }
+            trace.push({ phase: 'slip-settled', ...short(await state()), slip: slip === null ? null : +slip.toFixed(3), sinceReleaseS: +((Date.now() - tr) / 1000).toFixed(2) });
+        }
+        // coast: no drive torque, so a rolling wheel turns at exactly v / r. Guarded: the page ends the window early, and the car
+        // is braked at once, if going on would take it past the margin before what is ahead. The chase frame (pinned to the body:
+        // behind, left and above) is taken DURING the coast: the grounds have no room for the second it costs before or after.
+        const limitM = Number.isFinite(room1.ahead.distanceM) ? from + room1.ahead.distanceM - C.marginM : Infinity;
+        await frame.evaluate((c) => globalThis.__vqaVeh.setCam(c), { pos: [2.4, 1.5, -5.2], target: [0, 0.1, 0.6], fov: 40, near: 0.05 });
+        const sampling = frame.evaluate(({ ms, guard }) => globalThis.__vqaVeh.sampleSpin(ms, guard), {
+            ms: Math.round(C.coastS * 1000),
+            guard: Number.isFinite(limitM) ? { origin: p0.p, dir: heading, limitM, decel: C.brakeDecelMps2 } : null,
+        });
+        await page.waitForTimeout(120);
+        await shot('motion.driving', 'Rolling forward at speed (chase view, pinned to the body)', 'motion', 0);
+        const guarded = await sampling;
+        await clearCam();
+        const raw = Array.isArray(guarded) ? guarded : guarded.samples;
+        const stoppedForRoom = !Array.isArray(guarded) && guarded.stoppedForRoom;
+        if (stoppedForRoom)
+            await brakeTo0();
+        const { samples, impactAtS } = (0, vehicleClearance_1.trimAtImpact)(raw);
+        trace.push({ phase: 'coasted', ...short(await state()), ...(impactAtS !== null ? { impactAtS } : {}), ...(stoppedForRoom ? { stoppedForRoom: true } : {}) });
+        await brakeTo0();
+        trace.push({ phase: 'braked', ...short(await state()) });
+        // 3. back to the start, closed loop on position along the start heading, bounded
+        const back = {};
+        if (process.env.HELIX_VQA_DEBUG_PARK_AT_WALL) {
+            // Debug only (the caller records a harness error): park nose-on against what is ahead instead, the F40 round-1 end
+            // state, to prove the exterior cameras stay clear of scenery on their own.
+            const tb = Date.now();
+            for (;;) {
+                const r = await room();
+                if (!(r.ahead.distanceM > 0.35) || Date.now() - tb > 12_000)
+                    break;
+                await page.keyboard.down('KeyW');
+                await page.waitForTimeout(r.ahead.distanceM > 2 ? 160 : 60);
+                await page.keyboard.up('KeyW');
+                await page.waitForTimeout(120);
+            }
+            await brakeTo0();
+            const s = await state();
+            const r = await room();
+            Object.assign(back, { outcome: 'debug: parked against the scenery ahead (HELIX_VQA_DEBUG_PARK_AT_WALL)', endAlongM: +along(s.p).toFixed(2), clearAheadM: fin(r.ahead.distanceM), clearAheadBox: r.ahead.box });
+        }
+        else {
+            let held = [];
+            const hold = async (ks) => {
+                for (const k of held)
+                    if (!ks.includes(k))
+                        await page.keyboard.up(k);
+                for (const k of ks)
+                    if (!held.includes(k))
+                        await page.keyboard.down(k);
+                held = ks;
+            };
+            const tb = Date.now();
+            let last = 'coast';
+            let steps = 0;
+            try {
+                for (;;) {
+                    const s = await state();
+                    last = (0, vehicleClearance_1.returnStep)({ alongM: along(s.p), speedMps: s.fwd });
+                    if (last === 'done' || Date.now() - tb > C.returnMaxS * 1000)
+                        break;
+                    await hold(last === 'forward' ? ['KeyW'] : last === 'reverse' ? ['KeyS'] : last === 'brake' ? [s.fwd > 0 ? 'KeyS' : 'KeyW', 'Space'] : []);
+                    steps++;
+                    await page.waitForTimeout(60);
+                }
+            }
+            finally {
+                await hold([]);
+            }
+            await brakeTo0();
+            const s = await state();
+            Object.assign(back, { outcome: last === 'done' ? 'returned' : 'timed out', seconds: +((Date.now() - tb) / 1000).toFixed(1), steps, endAlongM: +along(s.p).toFixed(2), endAcrossM: +across(s.p).toFixed(2), endFromStartM: +Math.hypot(s.p[0] - p0.p[0], s.p[1] - p0.p[1]).toFixed(2) });
+            const room2 = await room();
+            Object.assign(back, { clearAheadM: fin(room2.ahead.distanceM), clearAheadBox: room2.ahead.box, clearBehindM: fin(room2.behind.distanceM), clearBehindBox: room2.behind.box });
+            trace.push({ phase: 'returned', ...short(s) });
+        }
+        const spin = (0, vehicleMath_1.spinAnalysis)(samples, rows.map((r) => r.id), radii);
+        return {
+            alive: aliveFacts,
+            spin,
+            mode: `keyboard (W/S/Space as the seated driver); sampled while coasting${impactAtS !== null ? ` (the first ${impactAtS} s, before the car met something)` : ''}${stoppedForRoom ? ' (ended early: the test grounds had no more room ahead; a harness limit, not the car)' : ''}`,
+            facts: { start: short(p0), trace, peakForwardSpeed: +peak.toFixed(2), samples: samples.length, rawSamples: raw.length, impactAtS, stoppedForRoom, radii: rows.map((r, k) => ({ id: r.id, axle: r.axle ?? null, roll: radii[k], contact: r.physicsRadius, drawn: r.radius })), end: back },
+        };
+    }
+    finally {
+        page.off('pageerror', onPageError);
+        page.off('console', onConsole);
+    }
+}
+//# sourceMappingURL=vehicle.js.map