@hypersoniclabs/helix-cli 0.1.6 → 0.1.23

package/dist/visualQa/scene.js

@@ -0,0 +1,688 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderScene = exports.MIN_STANDPOINTS = exports.MIN_SCENE_EXTENT_M = exports.SKY_RADIUS_M = exports.SETTLED_DY_M = exports.STAND_Y_TOLERANCE_M = exports.SPAWN_Y_TOLERANCE_M = exports.SPAWN_XZ_TOLERANCE_M = void 0;
+// THE SCENE ROUTE — opens a Home / World scene the way a visitor does and measures what they see.
+//
+// Why this exists: a `scene` item (itemType scene: a Home shell) has no single model, so the prop route errored with
+// "the pinned package names no model CID" and every Home in the catalogue was unjudgeable. A visitor meets a Home on
+// `/marketplace/homes/<id>/preview` (the walk-through: spawn in your own avatar and roam the empty home, no residence, no
+// purchase). This route loads exactly that page, then:
+//
+//   identity   the scene document the runtime streams (`shell=` in the Home frame URL) is fetched by the harness and
+//              hashed: it must be the PINNED package version's root document, byte for byte;
+//   spawn      the player appears at the document's declared spawn point, stands on something (stable y) and inside the
+//              declared placement bounds;
+//   walk       the harness picks a few standpoints from the live scene itself (ray probes through the runtime's own
+//              debug seam: first free direction, floor beneath), stands the visitor there and checks the player still
+//              stands (a missing floor collider drops them through the world);
+//   frames     the arrival view, the four directions from the spawn, a far "overview" standpoint and up to three
+//              walk-in standpoints, each captured after the streamer has settled;
+//   geometry   drawn bounds, NaN / collapsed / invisible meshes and textures over the whole scene minus the avatar and
+//              any sky-scale dome.
+//
+// The runtime's `?debug=1` seam (`window.__helixDevicesDebug`: `teleport`, `probe`, `player`) is what moves the player. It
+// is part of the production Home bundle; nothing here edits what the page draws except the camera it already owns and the
+// DOM chrome around the canvas (hidden for the screenshot).
+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 commonAsserts_1 = require("./commonAsserts");
+const resolve_1 = require("./resolve");
+const shot_1 = require("./shot");
+const viewerPage_1 = require("./viewerPage");
+const LOAD_TIMEOUT_MS = 150_000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const r3 = (v) => Math.round(v * 1000) / 1000;
+/** The player must stand within this of the document's spawn point (horizontal), and settle within this vertically. */
+exports.SPAWN_XZ_TOLERANCE_M = 2.5;
+exports.SPAWN_Y_TOLERANCE_M = 3;
+/** After a teleport the player may differ this much from the probed floor height and still count as standing on it. */
+exports.STAND_Y_TOLERANCE_M = 1.2;
+/** The player y may change at most this between two reads a second apart for "standing still on something". */
+exports.SETTLED_DY_M = 0.08;
+/** Meshes whose world bounding radius exceeds this are sky / horizon domes, not part of the scene's measured extent. */
+exports.SKY_RADIUS_M = 1500;
+/** The scene's measured extent must be at least this large (largest dimension). */
+exports.MIN_SCENE_EXTENT_M = 3;
+exports.MIN_STANDPOINTS = 2;
+async function getJson(url) {
+    for (let attempt = 0;; attempt++) {
+        const res = await fetch(url, { headers: { accept: 'application/json' } });
+        if (res.ok)
+            return (await res.json());
+        if ((res.status === 429 || res.status >= 500) && attempt < 4) {
+            await sleep(1500 * 2 ** attempt);
+            continue;
+        }
+        throw new Error(`GET ${url} → ${res.status}`);
+    }
+}
+const renderScene = async (ctx) => {
+    const started = Date.now();
+    const item = ctx.resolved;
+    const title = item.identity.title;
+    const result = {
+        route: 'home-preview', url: '', frames: [], asserts: [], facts: { category: 'scene', timings: {} }, subjects: [], errors: [],
+        renderer: null, engineVersion: null, fetchedAssets: [],
+    };
+    const timings = result.facts.timings;
+    const api = ctx.apiBase.replace(/\/$/, '');
+    const pkg = item.identity;
+    if (!pkg.packageId || !pkg.packageVersion) {
+        result.errors.push('the item has no Continuum package pin, so there is no pinned scene document to prove');
+        return result;
+    }
+    // ── the pinned scene document ──────────────────────────────────────────────────────────────────────────────────
+    let rootHex = null;
+    let doc = {};
+    let provenanceSource = null;
+    try {
+        const ver = await getJson(`${api}/api/v1/continuum/public/packages/${pkg.packageId}/versions/${encodeURIComponent(pkg.packageVersion)}`);
+        rootHex = (0, resolve_1.hexOf)(ver.manifest.root?.cid);
+        if (!rootHex)
+            throw new Error('the pinned package version names no root document');
+        doc = await getJson(`${api}/api/v1/continuum/public/objects/sha256:${rootHex}`);
+        result.facts.pinnedRoot = { cid: ver.manifest.root?.cid, role: ver.manifest.root?.role, mediaType: ver.manifest.root?.mediaType, provenance: ver.manifest.provenance };
+        provenanceSource = ver.manifest.provenance?.source ?? null;
+    }
+    catch (e) {
+        result.errors.push(`could not read the pinned scene document: ${String(e?.message ?? e)}`);
+        return result;
+    }
+    const spawn = doc.spawns?.[0];
+    const bounds = doc.placement?.bounds;
+    const bmin = (bounds?.min ?? null);
+    const bmax = (bounds?.max ?? null);
+    result.facts.doc = { spawns: doc.spawns, placementBounds: bounds };
+    if (!spawn?.position || spawn.position.length !== 3) {
+        result.errors.push('the pinned scene document declares no spawn point');
+        return result;
+    }
+    const spawnPos = spawn.position;
+    const url = `${ctx.webBase.replace(/\/$/, '')}/marketplace/homes/${item.identity.itemId}/preview?debug=1`;
+    result.url = url;
+    const b = await (0, browser_1.launchVqaBrowser)({ storageState: ctx.storageState, executablePath: ctx.executablePath, width: 1280, height: 800 });
+    const requests = [];
+    b.ctx.on('request', (req) => { const u = req.url(); if (/\.(glb|gltf|ktx2|json|bin)(\?|$)|\/content\/sha256\/|\/continuum\/(public\/)?objects\/|scene-v2\//i.test(u) && !requests.includes(u))
+        requests.push(u); });
+    try {
+        const t0 = Date.now();
+        await b.page.goto(url, { waitUntil: 'domcontentloaded' });
+        let frame;
+        try {
+            // A Scene v2 Home exposes the runtime's debug seam; a legacy home-shell Home (world.json) never does, so after the
+            // meshes have streamed in without a seam it is judged as what it is rather than waited on forever.
+            const tStart = Date.now();
+            frame = await (0, browser_1.findFrame)(b.page, () => {
+                const d = window.__helixDevicesDebug;
+                const s = window.__vqa?.scene;
+                if (!s || !(window.__vqa.frames > 60))
+                    return false;
+                let n = 0;
+                s.traverse((o) => { if (o.isMesh)
+                    n++; });
+                if (d && typeof d.teleport === 'function' && typeof d.probe === 'function' && n > 120 && !!d.player)
+                    return true;
+                return n > 20 && !d && !/scene=v2/.test(window.location.search) && window.__vqa.frames > 400;
+            }, LOAD_TIMEOUT_MS);
+            timings.findFrameMs = Date.now() - tStart;
+        }
+        catch (e) {
+            const text = await b.page.evaluate(() => String(document.body?.innerText ?? '').replace(/\s+/g, ' ').slice(0, 240)).catch(() => '');
+            result.errors.push(`the Home walk-through never became playable (${String(e?.message ?? e)}; page says: "${text}")`);
+            return result;
+        }
+        await frame.evaluate(commonAsserts_1.INSTALL_SCENE_STATS);
+        await frame.evaluate(viewerPage_1.INSTALL_VIEWER_PAGE);
+        timings.frameReady = Date.now() - t0;
+        await settleScene(frame, 8000);
+        timings.loaded = Date.now() - t0;
+        const seam = await frame.evaluate(() => typeof window.__helixDevicesDebug?.teleport === 'function' && typeof window.__helixDevicesDebug?.probe === 'function');
+        const shellUrl = new URL(frame.url()).searchParams.get('shell');
+        if (!seam)
+            return await runLegacy(ctx, b, frame, result, { shellUrl, requests, spawnPos, bmin, bmax, provenanceSource, rootHex });
+        // ── identity: the document the runtime streams is the pinned one ─────────────────────────────────────────────
+        const identity = { shellUrl, sha256: null, pinnedSha256: rootHex, match: false, requested: !!shellUrl && requests.includes(shellUrl), fetchError: null };
+        if (shellUrl) {
+            try {
+                const res = await fetch(shellUrl);
+                if (res.ok) {
+                    identity.sha256 = node_crypto_1.default.createHash('sha256').update(Buffer.from(await res.arrayBuffer())).digest('hex');
+                    identity.match = identity.sha256 === rootHex;
+                }
+                else
+                    identity.fetchError = `GET → ${res.status}`;
+            }
+            catch (e) {
+                identity.fetchError = String(e?.message ?? e).slice(0, 120);
+            }
+        }
+        result.facts.identity = identity;
+        result.asserts.push({
+            id: 'scene.identity', pass: identity.match && identity.requested, severity: 'block',
+            detail: identity.match
+                ? `the scene document the Home runtime streamed (${shellUrl?.split('/').slice(-3).join('/')}) hashes to the pinned root ${rootHex?.slice(0, 12)}…`
+                : !shellUrl ? 'the Home frame was not given a scene document (no shell= parameter)'
+                    : identity.sha256 ? `the scene document the runtime streams hashes to ${identity.sha256.slice(0, 12)}…, not the pinned root ${rootHex?.slice(0, 12)}…: the visitor is walking a different version than the one pinned`
+                        : `the scene document the runtime streams (${shellUrl.split('/').slice(-2).join('/')}) could not be read to compare with the pinned root ${rootHex?.slice(0, 12)}… (${identity.fetchError ?? 'no answer'}): the visitor is not shown a Scene v2 document of the pinned version`,
+            measured: { shell: shellUrl, sha256: identity.sha256, pinned: rootHex, requestedByPage: identity.requested },
+        });
+        // ── chrome: leave only the Home canvas (HUD, prompts and the page shell are not the scene) ─────────────────
+        await hideChrome(b.page, frame);
+        // ── spawn ───────────────────────────────────────────────────────────────────────────────────────────────────
+        const p0 = await player(frame);
+        await sleep(1000);
+        const p1 = await player(frame);
+        const dxz = Math.hypot(p1[0] - spawnPos[0], p1[2] - spawnPos[2]);
+        const dy = Math.abs(p1[1] - spawnPos[1]);
+        const settled = Math.abs(p1[1] - p0[1]) <= exports.SETTLED_DY_M;
+        const inBounds = !bmin || !bmax || (p1[0] >= bmin[0] && p1[0] <= bmax[0] && p1[2] >= bmin[2] && p1[2] <= bmax[2] && p1[1] >= bmin[1] - 1 && p1[1] <= bmax[1] + 1);
+        result.facts.spawn = { declared: spawnPos, player: p1, dxz: r3(dxz), dy: r3(dy), settled, inBounds };
+        const spawnOk = Number.isFinite(dxz) && dxz <= exports.SPAWN_XZ_TOLERANCE_M && dy <= exports.SPAWN_Y_TOLERANCE_M && settled && inBounds;
+        result.asserts.push({
+            id: 'scene.spawn_valid', pass: spawnOk, severity: 'block',
+            detail: spawnOk
+                ? `the visitor appears at (${p1.map((v) => v.toFixed(2)).join(', ')}), ${dxz.toFixed(2)} m from the declared spawn, standing still inside the placement bounds`
+                : `the visitor appears at (${p1.map((v) => v.toFixed(2)).join(', ')}) but the document declares (${spawnPos.join(', ')}): ${dxz > exports.SPAWN_XZ_TOLERANCE_M || dy > exports.SPAWN_Y_TOLERANCE_M ? `${dxz.toFixed(1)} m horizontally and ${dy.toFixed(1)} m vertically away` : ''}${settled ? '' : ' still falling/moving after 1 s (nothing under the spawn?)'}${inBounds ? '' : ' outside the placement bounds'}`,
+            measured: { declared: spawnPos, player: p1, dxz: r3(dxz), dy: r3(dy), settled, inBounds },
+        });
+        // ── standpoints picked from the live scene ───────────────────────────────────────────────────────────────────
+        const frames = [];
+        const images = [];
+        const shoot = async (id, label, group) => {
+            await frame.evaluate(() => __vqv.frames(6));
+            await sleep(250);
+            const file = node_path_1.default.join('frames', `${id.replace(/[^A-Za-z0-9._-]/g, '_')}.jpg`);
+            const abs = node_path_1.default.join(ctx.outDir, file);
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(abs), { recursive: true });
+            const loc = b.page.locator('iframe[src*="first-party-runtimes/home"]').first();
+            node_fs_1.default.writeFileSync(abs, await (0, shot_1.shotJpeg)(b.page, loc));
+            const box = await loc.boundingBox();
+            const f = { id, label, group, file, width: Math.round(box?.width ?? 0), height: Math.round(box?.height ?? 0) };
+            result.frames.push(f);
+            frames.push(f);
+            images.push({ ...(await (0, commonAsserts_1.imageStats)(abs)), file });
+        };
+        await shoot('scene.arrival', `${title} — arrival: what the visitor sees on entering`, 'exterior');
+        const cardinal = [['east', [1, 0, 0]], ['south', [0, 0, 1]], ['west', [-1, 0, 0]], ['north', [0, 0, -1]]];
+        for (const [name, d] of cardinal) {
+            await frame.evaluate(([pos, dir]) => window.__helixDevicesDebug.teleport(pos, [pos[0] + dir[0] * 10, pos[1], pos[2] + dir[2] * 10]), [p1, d]);
+            await settleScene(frame, 2500);
+            await shoot(`scene.spawn.${name}`, `${title} — from the spawn point, looking ${name}`, 'exterior');
+        }
+        const points = await pickStandpoints(frame, p1);
+        result.facts.standpoints = points;
+        const walked = [];
+        for (const sp of points) {
+            await frame.evaluate(([pos, look]) => window.__helixDevicesDebug.teleport(pos, look), [sp.pos, sp.look]);
+            await settleScene(frame, 3500);
+            const a = await player(frame);
+            await sleep(900);
+            const c = await player(frame);
+            const stood = Math.abs(c[1] - sp.floorY) <= exports.STAND_Y_TOLERANCE_M && Math.abs(c[1] - a[1]) <= exports.SETTLED_DY_M;
+            walked.push({ id: sp.id, target: sp.pos, floorY: sp.floorY, landed: c, stood, dy: r3(c[1] - sp.floorY) });
+            await shoot(`scene.${sp.id}`, `${title} — ${sp.label}`, sp.group);
+        }
+        result.facts.walked = walked;
+        const fell = walked.filter((w) => !w.stood);
+        const walkOk = walked.length >= exports.MIN_STANDPOINTS && fell.length === 0;
+        result.asserts.push({
+            id: 'scene.walkable', pass: walkOk, severity: 'block',
+            detail: walked.length < exports.MIN_STANDPOINTS
+                ? `only ${walked.length} standpoint(s) with a floor under them could be found from the spawn (needs ≥ ${exports.MIN_STANDPOINTS}): the visitor has nowhere to go`
+                : fell.length
+                    ? `the visitor did not stay on the floor at ${fell.length} of ${walked.length} standpoints (${fell.map((w) => `${w.id}: landed ${w.dy.toFixed(1)} m from the probed floor`).join('; ')}) — collision is missing under walkable floor`
+                    : `the visitor stood on the floor at all ${walked.length} standpoints probed from the live scene (within ${exports.STAND_Y_TOLERANCE_M} m of the floor, settled)`,
+            measured: { walked },
+        });
+        // ── geometry over the whole scene ───────────────────────────────────────────────────────────────────────────
+        const stats = (await frame.evaluate(() => {
+            const s = window.__vqa.scene;
+            s.updateMatrixWorld(true);
+            const sphere = (o) => { const g = o.geometry; if (!g)
+                return 0; if (!g.boundingSphere)
+                g.computeBoundingSphere(); const bs = g.boundingSphere; if (!bs)
+                return 0; const e = o.matrixWorld.elements; const sc = Math.max(Math.hypot(e[0], e[1], e[2]), Math.hypot(e[4], e[5], e[6]), Math.hypot(e[8], e[9], e[10])); return bs.radius * sc; };
+            let sky = 0;
+            const out = __vqaStats(s, { exclude: (o) => { if (o.isSkinnedMesh)
+                    return true; if (sphere(o) > 1500) {
+                    sky++;
+                    return true;
+                } return false; } });
+            return { ...out, skyScaleMeshesExcluded: sky };
+        }));
+        result.facts.sceneStats = { ...stats, bounds: stats.bounds };
+        const sb = stats.bounds;
+        const overlaps = !!sb && (!bmin || !bmax || (sb.min[0] <= bmax[0] && sb.max[0] >= bmin[0] && sb.min[1] <= bmax[1] && sb.max[1] >= bmin[1] && sb.min[2] <= bmax[2] && sb.max[2] >= bmin[2]));
+        const holdsSpawn = !!sb && spawnPos[0] >= sb.min[0] - 2 && spawnPos[0] <= sb.max[0] + 2 && spawnPos[2] >= sb.min[2] - 2 && spawnPos[2] <= sb.max[2] + 2;
+        const extent = sb ? Math.max(...sb.size) : 0;
+        const plausible = !!sb && overlaps && holdsSpawn && extent >= exports.MIN_SCENE_EXTENT_M;
+        result.asserts.push({
+            id: 'scene.bounds_plausible', pass: plausible, severity: 'block',
+            detail: !sb ? 'the scene drew no measurable geometry'
+                : plausible
+                    ? `the drawn scene spans ${sb.size.map((v) => v.toFixed(1)).join(' × ')} m, overlaps the declared placement bounds and contains the spawn point`
+                    : `the drawn scene (${sb.size.map((v) => v.toFixed(1)).join(' × ')} m, y ${sb.min[1].toFixed(1)}…${sb.max[1].toFixed(1)}) ${!overlaps ? 'does not overlap the declared placement bounds' : !holdsSpawn ? 'does not contain the spawn point' : `is under ${exports.MIN_SCENE_EXTENT_M} m`}`,
+            measured: { drawn: sb, placement: bounds, spawn: spawnPos, skyScaleMeshesExcluded: stats.skyScaleMeshesExcluded },
+        });
+        result.asserts.push(...(0, commonAsserts_1.commonAsserts)('scene', stats, images, { minTriangles: 200 }));
+        result.renderer = await (0, browser_1.rendererInfo)(b.page);
+    }
+    finally {
+        result.fetchedAssets = [...new Set([...b.fetchedAssets, ...requests])].slice(0, 400);
+        if (b.pageErrors.length)
+            result.facts.pageErrors = b.pageErrors.slice(0, 20);
+        await b.close();
+    }
+    timings.total = Date.now() - started;
+    return result;
+};
+exports.renderScene = renderScene;
+async function player(frame) {
+    const p = (await frame.evaluate(() => { const q = window.__helixDevicesDebug?.player; return q ? [q.x, q.y, q.z] : null; }));
+    return (p ?? [NaN, NaN, NaN]);
+}
+/** Wait until the drawn mesh count stops changing (the streamer has caught up) and at least `minMs` has passed. */
+async function settleScene(frame, minMs) {
+    const t0 = Date.now();
+    let last = -1;
+    let same = 0;
+    let n = 0;
+    while (Date.now() - t0 < 45_000) {
+        n = (await frame.evaluate(() => { let c = 0; window.__vqa.scene.traverse((o) => { if (o.isMesh && o.visible)
+            c++; }); return c; }).catch(() => -1));
+        if (n === last && n > 0) {
+            same++;
+        }
+        else {
+            same = 0;
+            last = n;
+        }
+        if (same >= 4 && Date.now() - t0 >= minMs)
+            return n;
+        await sleep(800);
+    }
+    return n;
+}
+/** Hide everything on the page (and in the Home frame) that is not the Home canvas: HUD, prompts, the shell. */
+async function hideChrome(page, frame) {
+    await frame.evaluate(() => __vqv.isolateCanvas());
+    await page.evaluate(() => {
+        const el = document.querySelector('iframe[src*="first-party-runtimes/home"]');
+        if (!el)
+            return;
+        for (let node = el; node && node !== document.body && node.parentElement; node = node.parentElement) {
+            for (const sib of node.parentElement.children)
+                if (sib !== node && sib.style) {
+                    sib.style.setProperty('visibility', 'hidden', 'important');
+                    sib.style.setProperty('opacity', '0', 'important');
+                }
+        }
+    });
+}
+/**
+ * Choose up to four extra standpoints from the live scene: one far overview, up to three INTERIOR points (a floor under
+ * the feet and a ceiling 2–7 m overhead, found by ray probes over a grid around the spawn on three levels) and, when the
+ * spawn has no interior near it, walk-ins along free directions. Every point has a verified floor.
+ */
+async function pickStandpoints(frame, from) {
+    const free = (await frame.evaluate(([origin]) => {
+        const dbg = window.__helixDevicesDebug;
+        const out = [];
+        for (let k = 0; k < 8; k++) {
+            const a = (k / 8) * Math.PI * 2;
+            const d = [Math.sin(a), 0, Math.cos(a)];
+            const hit = dbg.probe([origin[0] + d[0] * 0.8, origin[1] + 1.4, origin[2] + d[2] * 0.8], d);
+            out.push({ dir: d, len: hit ? hit.distance : 60 });
+        }
+        return out;
+    }, [from]));
+    free.sort((a, b) => b.len - a.len);
+    const floorAt = async (x, y, z) => (await frame.evaluate(([px, py, pz]) => {
+        const hit = window.__helixDevicesDebug.probe([px, py + 1.2, pz], [0, -1, 0]);
+        return hit && hit.normal && hit.normal[1] > 0.5 && hit.distance < 5 ? hit.point[1] : null;
+    }, [x, y, z]));
+    const out = [];
+    // Far overview: the longest free direction, as far out as there is floor, looking back at the spawn.
+    const top = free[0];
+    for (const f of [0.85, 0.6, 0.4, 0.25]) {
+        const reach = Math.min(top.len * f, 40);
+        if (reach < 4)
+            continue;
+        const x = from[0] + top.dir[0] * reach;
+        const z = from[2] + top.dir[2] * reach;
+        const fy = await floorAt(x, from[1], z);
+        if (fy === null)
+            continue;
+        out.push({ id: 'overview', label: `overview from ${reach.toFixed(0)} m out, looking back at the spawn`, group: 'exterior', pos: [x, fy + 0.1, z], look: [from[0], from[1] + 1.5, from[2]], floorY: fy });
+        break;
+    }
+    // Interior candidates: floor underfoot, a ceiling overhead.
+    const cands = (await frame.evaluate(([origin]) => {
+        const dbg = window.__helixDevicesDebug;
+        const found = [];
+        for (const dyLevel of [0, 4, -4]) {
+            for (let gx = -42; gx <= 42; gx += 6) {
+                for (let gz = -42; gz <= 42; gz += 6) {
+                    const x = origin[0] + gx, z = origin[2] + gz;
+                    const down = dbg.probe([x, origin[1] + dyLevel + 2.5, z], [0, -1, 0]);
+                    if (!down || !down.normal || down.normal[1] < 0.6 || down.distance > 8)
+                        continue;
+                    const fy = down.point[1];
+                    const up = dbg.probe([x, fy + 0.3, z], [0, 1, 0]);
+                    if (up && up.distance >= 2 && up.distance <= 7)
+                        found.push({ x, z, y: fy, ceil: up.distance });
+                }
+            }
+        }
+        return found;
+    }, [from]));
+    const picked = [];
+    const pool = cands.filter((c) => Math.hypot(c.x - from[0], c.z - from[2]) >= 4);
+    while (picked.length < 3 && pool.length) {
+        // Farthest-point sampling: the candidate farthest from the spawn and from everything already picked.
+        let best = -1;
+        let bestD = -1;
+        pool.forEach((c, i) => { const d = Math.min(Math.hypot(c.x - from[0], c.z - from[2]), ...picked.map((p) => Math.hypot(c.x - p.x, c.z - p.z))); if (d > bestD) {
+            bestD = d;
+            best = i;
+        } });
+        if (bestD < 5)
+            break;
+        picked.push(pool.splice(best, 1)[0]);
+    }
+    let n = 0;
+    for (const c of picked) {
+        n++;
+        // Look along the longest clear line of sight from there (a room's long axis), not at the nearest wall.
+        const sight = (await frame.evaluate(([x, y, z]) => {
+            const dbg = window.__helixDevicesDebug;
+            let bestLen = -1;
+            let bestDir = [0, 0, 1];
+            for (let k = 0; k < 8; k++) {
+                const a = (k / 8) * Math.PI * 2;
+                const d = [Math.sin(a), 0, Math.cos(a)];
+                const hit = dbg.probe([x, y + 1.4, z], d);
+                const len = hit ? hit.distance : 30;
+                if (len > bestLen) {
+                    bestLen = len;
+                    bestDir = d;
+                }
+            }
+            return { dir: bestDir, len: bestLen };
+        }, [c.x, c.y, c.z]));
+        out.push({ id: `interior${n}`, label: `inside, ${Math.hypot(c.x - from[0], c.z - from[2]).toFixed(0)} m from the spawn, looking along the longest sight line (${sight.len.toFixed(0)} m)`, group: 'interior', pos: [c.x, c.y + 0.1, c.z], look: [c.x + sight.dir[0] * 10, c.y + 1.5, c.z + sight.dir[2] * 10], floorY: c.y });
+    }
+    // No interior near the spawn: fall back to walk-ins along free directions.
+    const used = out.length ? [top.dir] : [];
+    const near = (d) => used.some((u) => u[0] * d[0] + u[2] * d[2] > 0.7);
+    let w = 0;
+    for (const cand of free.slice(1)) {
+        if (out.length >= 4)
+            break;
+        if (near(cand.dir) || cand.len < 3)
+            continue;
+        for (const f of [0.6, 0.4]) {
+            const reach = Math.min(cand.len * f, 14);
+            const x = from[0] + cand.dir[0] * reach;
+            const z = from[2] + cand.dir[2] * reach;
+            const fy = await floorAt(x, from[1], z);
+            if (fy === null)
+                continue;
+            w++;
+            out.push({ id: `walk${w}`, label: `${reach.toFixed(0)} m from the spawn, looking onward`, group: 'exterior', pos: [x, fy + 0.1, z], look: [x + cand.dir[0] * 10, fy + 1.5, z + cand.dir[2] * 10], floorY: fy });
+            used.push(cand.dir);
+            break;
+        }
+    }
+    return out;
+}
+const LEGACY_SPAWN_XZ_M = 0.75;
+const LEGACY_SPAWN_Y_M = 1.2;
+const LEGACY_WALK_MIN_M = 0.6;
+const LEGACY_WALK_MAX_DY_M = 0.7;
+async function runLegacy(ctx, b, frame, result, input) {
+    const item = ctx.resolved;
+    const title = item.identity.title;
+    result.facts.runtime = 'legacy-home-shell';
+    const { shellUrl } = input;
+    // identity
+    const assets = (item.item.assets ?? []);
+    const readyShell = assets.filter((a) => a.rendition === 'home-shell' && (a.status ?? 'ready') === 'ready').map((a) => a.cdnUrl);
+    let manifest = null;
+    let manifestError = null;
+    // The runtime is given the bundle's directory; the manifest sits at <dir>/world.json.
+    const manifestUrl = shellUrl ? (/\.json(\?|$)/.test(shellUrl) ? shellUrl : `${shellUrl.replace(/\/$/, '')}/world.json`) : null;
+    if (manifestUrl) {
+        try {
+            const res = await fetch(manifestUrl);
+            if (res.ok)
+                manifest = (await res.json());
+            else
+                manifestError = `GET → ${res.status}`;
+        }
+        catch (e) {
+            manifestError = String(e?.message ?? e).slice(0, 120);
+        }
+    }
+    const sameAsset = !!manifestUrl && readyShell.includes(manifestUrl);
+    const forThisItem = manifest?.format === 'helix.home.shell/1' && manifest?.generator?.itemId === item.identity.itemId;
+    const derivedFromShell = !!manifest?.id && !!input.provenanceSource && input.provenanceSource.includes(manifest.id);
+    result.facts.identity = { runtime: 'legacy-home-shell', shellUrl, readyShellAssets: readyShell, manifestId: manifest?.id ?? null, manifestItemId: manifest?.generator?.itemId ?? null, provenance: input.provenanceSource, requested: !!manifestUrl && input.requests.some((u) => u.startsWith(shellUrl)), manifestUrl, manifestError };
+    result.asserts.push({
+        id: 'scene.identity', pass: sameAsset && forThisItem && derivedFromShell && !!shellUrl && input.requests.some((u) => u.startsWith(shellUrl)), severity: 'block',
+        detail: sameAsset && forThisItem && derivedFromShell
+            ? `legacy home-shell lane: the visitor streams the item's own Ready HomeShell asset (${manifest?.id}, compiled for this item) and the pinned Scene Package ${input.rootHex?.slice(0, 12)}… was derived from that shell (provenance "${input.provenanceSource}"). The visitor does NOT stream the pinned Scene document itself on this lane.`
+            : !shellUrl ? 'the Home frame was not given a shell (no shell= parameter)'
+                : !sameAsset ? `the runtime streams ${shellUrl.split('/').slice(-3).join('/')}, which is not the item's Ready HomeShell asset (${readyShell.map((u) => u?.split('/').slice(-3).join('/')).join(', ') || 'none'})`
+                    : !forThisItem ? `the shell manifest (${manifestError ?? `${manifest?.format}, itemId ${manifest?.generator?.itemId}`}) was not compiled for this item`
+                        : `the pinned Scene Package's provenance ("${input.provenanceSource}") does not name the streamed shell "${manifest?.id}": the pinned version is not what was derived from the shell the visitor walks`,
+        measured: { runtime: 'legacy-home-shell', shell: shellUrl, readyShellAssets: readyShell, manifestId: manifest?.id ?? null, provenance: input.provenanceSource, pinnedRoot: input.rootHex },
+    });
+    await hideChrome(b.page, frame);
+    // The player's own body is the ground truth for "where the visitor stands".
+    const body = async () => (await frame.evaluate(() => {
+        const s = window.__vqa.scene;
+        s.updateMatrixWorld(true);
+        let best = null;
+        s.traverse((o) => { if (!best && o.isSkinnedMesh && o.visible)
+            best = o; });
+        if (!best)
+            return null;
+        const e = best.matrixWorld.elements;
+        return [e[12], e[13], e[14]];
+    }));
+    const spawn = manifest?.spawnPoint?.position ? [manifest.spawnPoint.position.x, manifest.spawnPoint.position.y, manifest.spawnPoint.position.z] : null;
+    const p0 = await body();
+    await sleep(1000);
+    const p1 = await body();
+    const settled = !!p0 && !!p1 && Math.abs(p1[1] - p0[1]) <= exports.SETTLED_DY_M && Math.hypot(p1[0] - p0[0], p1[2] - p0[2]) <= 0.05;
+    const dxz = p1 && spawn ? Math.hypot(p1[0] - spawn[0], p1[2] - spawn[2]) : NaN;
+    const dy = p1 && spawn ? Math.abs(p1[1] - spawn[1]) : NaN;
+    const bmin = spawn && manifest?.metrics?.boundsM ? manifest.metrics.boundsM.min : input.bmin;
+    const bmax = spawn && manifest?.metrics?.boundsM ? manifest.metrics.boundsM.max : input.bmax;
+    const spawnOk = !!p1 && !!spawn && dxz <= LEGACY_SPAWN_XZ_M && dy <= LEGACY_SPAWN_Y_M && settled;
+    result.facts.spawn = { declared: spawn, player: p1, dxz: r3(dxz), dy: r3(dy), settled };
+    result.asserts.push({
+        id: 'scene.spawn_valid', pass: spawnOk, severity: 'block',
+        detail: spawnOk
+            ? `the visitor's body stands at (${p1.map((v) => v.toFixed(2)).join(', ')}), ${dxz.toFixed(2)} m from the shell's declared spawn point, standing still`
+            : !p1 ? 'no player body was drawn in the Home' : !spawn ? 'the shell manifest declares no spawn point'
+                : `the visitor's body is at (${p1.map((v) => v.toFixed(2)).join(', ')}) but the shell declares (${spawn.join(', ')}): ${dxz.toFixed(1)} m horizontally, ${dy.toFixed(1)} m vertically${settled ? '' : ', and still moving'}`,
+        measured: { declared: spawn, player: p1, dxz: r3(dxz), dy: r3(dy), settled },
+    });
+    // walkable: a floor under the player, and a held W moves the player along it.
+    const floorAt = async (pts, fromY) => (await frame.evaluate(([p, y]) => window.__helixHomeFloorProbe ? window.__helixHomeFloorProbe(p, y) : null, [pts, fromY]).catch(() => null)) ?? [];
+    const under = p1 ? (await floorAt([{ x: p1[0], z: p1[2] }], p1[1] + 1.2))?.[0] ?? null : null;
+    const standsOnFloor = !!under && under.surfaceY !== null && Math.abs((p1?.[1] ?? 0) - under.surfaceY) <= 0.35;
+    let walked = 0;
+    let walkDy = NaN;
+    let walkError = null;
+    try {
+        await b.page.locator('iframe[src*="first-party-runtimes/home"]').first().click({ position: { x: 640, y: 400 }, timeout: 5000 }).catch(() => undefined);
+        const before = await body();
+        await b.page.keyboard.down('w');
+        await sleep(2500);
+        await b.page.keyboard.up('w');
+        await sleep(600);
+        const after = await body();
+        if (before && after) {
+            walked = Math.hypot(after[0] - before[0], after[2] - before[2]);
+            walkDy = after[1] - before[1];
+        }
+    }
+    catch (e) {
+        walkError = String(e?.message ?? e).slice(0, 120);
+    }
+    const walkOk = standsOnFloor && walked >= LEGACY_WALK_MIN_M && Math.abs(walkDy) <= LEGACY_WALK_MAX_DY_M;
+    result.facts.walkable = { floorUnderPlayer: under, standsOnFloor, walkedM: r3(walked), walkDy: r3(walkDy), walkError };
+    result.asserts.push({
+        id: 'scene.walkable', pass: walkOk, severity: 'block',
+        detail: walkOk
+            ? `a floor (y ${under?.surfaceY?.toFixed(2)}) lies under the visitor and holding W walked them ${walked.toFixed(1)} m along it (height change ${walkDy.toFixed(2)} m)`
+            : !standsOnFloor ? `no floor within 35 cm under the visitor's feet (probe: ${under?.surfaceY ?? 'none'} vs body ${p1?.[1]?.toFixed(2)})`
+                : `holding W moved the visitor only ${Number.isFinite(walked) ? walked.toFixed(2) : '?'} m (needs ≥ ${LEGACY_WALK_MIN_M}) with a ${Number.isFinite(walkDy) ? walkDy.toFixed(2) : '?'} m height change${walkError ? ` (${walkError})` : ''}`,
+        measured: { under, walked: r3(walked), walkDy: r3(walkDy) },
+    });
+    // frames
+    const images = [];
+    const shoot = async (id, label, group) => {
+        await frame.evaluate(() => __vqv.frames(6));
+        await sleep(300);
+        const file = node_path_1.default.join('frames', `${id.replace(/[^A-Za-z0-9._-]/g, '_')}.jpg`);
+        const abs = node_path_1.default.join(ctx.outDir, file);
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(abs), { recursive: true });
+        const loc = b.page.locator('iframe[src*="first-party-runtimes/home"]').first();
+        node_fs_1.default.writeFileSync(abs, await (0, shot_1.shotJpeg)(b.page, loc));
+        const box = await loc.boundingBox();
+        result.frames.push({ id, label, group, file, width: Math.round(box?.width ?? 0), height: Math.round(box?.height ?? 0) });
+        images.push({ ...(await (0, commonAsserts_1.imageStats)(abs)), file });
+    };
+    await shoot('scene.arrival', `${title} — the visitor on arrival, in the game's own third-person camera`, 'exterior');
+    // Our own camera: wrap the render call so a pose we set survives the game's per-frame camera follow.
+    await frame.evaluate(() => {
+        const H = window.__vqa;
+        if (window.__vqCamHooked)
+            return;
+        window.__vqCamHooked = true;
+        for (const r of H.renderers) {
+            const orig = r.render.bind(r);
+            r.render = (scene, camera) => {
+                const o = window.__vqCam;
+                if (o && camera === H.main) {
+                    camera.position.set(o.pos[0], o.pos[1], o.pos[2]);
+                    camera.up.set(0, 1, 0);
+                    camera.lookAt(o.look[0], o.look[1], o.look[2]);
+                    if (o.fov) {
+                        camera.fov = o.fov;
+                        camera.updateProjectionMatrix();
+                    }
+                    camera.updateMatrixWorld(true);
+                }
+                return orig(scene, camera);
+            };
+        }
+    });
+    const place = async (pos, look, fov = 70) => { await frame.evaluate(([p, l, f]) => { window.__vqCam = { pos: p, look: l, fov: f }; }, [pos, look, fov]); await sleep(500); };
+    // The drawn scene without sky domes and the player.
+    const stats = (await frame.evaluate(() => {
+        const s = window.__vqa.scene;
+        s.updateMatrixWorld(true);
+        const radius = (o) => { const g = o.geometry; if (!g)
+            return 0; if (!g.boundingSphere)
+            g.computeBoundingSphere(); const bs = g.boundingSphere; if (!bs)
+            return 0; const e = o.matrixWorld.elements; return bs.radius * Math.max(Math.hypot(e[0], e[1], e[2]), Math.hypot(e[4], e[5], e[6]), Math.hypot(e[8], e[9], e[10])); };
+        let sky = 0;
+        const out = window.__vqaStats(s, { exclude: (o) => { if (o.isSkinnedMesh)
+                return true; if (radius(o) > 1500) {
+                sky++;
+                return true;
+            } return false; } });
+        return { ...out, skyScaleMeshesExcluded: sky };
+    }));
+    result.facts.sceneStats = { ...stats };
+    const sb = stats.bounds;
+    const centre = sb ? [(sb.min[0] + sb.max[0]) / 2, (sb.min[1] + sb.max[1]) / 2, (sb.min[2] + sb.max[2]) / 2] : (p1 ?? [0, 0, 0]);
+    const around = p1 ?? centre;
+    // Exterior: four views from outside the house looking at it, from the spawn side outwards (the spawn is a front court).
+    const reach = Math.min(Math.max(...(sb?.size ?? [30, 30, 30])) * 0.35, 45);
+    const dirs = [['east', [1, 0, 0]], ['south', [0, 0, 1]], ['west', [-1, 0, 0]], ['north', [0, 0, -1]]];
+    for (const [name, d] of dirs) {
+        await place([around[0] + d[0] * reach, around[1] + reach * 0.45, around[2] + d[2] * reach], [around[0], around[1] + 1, around[2]]);
+        await shoot(`scene.outside.${name}`, `${title} — from ${reach.toFixed(0)} m ${name} of the spawn, looking at it`, 'exterior');
+    }
+    // From the spawn at eye height in four directions: where the visitor actually is.
+    for (const [name, d] of dirs) {
+        await place([around[0], around[1] + 1.6, around[2]], [around[0] + d[0] * 8, around[1] + 1.4, around[2] + d[2] * 8], 75);
+        await shoot(`scene.spawn.${name}`, `${title} — from the spawn point at eye height, looking ${name}`, 'interior');
+    }
+    // Covered standpoints: floor + headroom probes on a grid at two storey heights around the spawn.
+    const grid = [];
+    for (let gx = -36; gx <= 36; gx += 3)
+        for (let gz = -36; gz <= 36; gz += 3)
+            grid.push({ x: around[0] + gx, z: around[2] + gz });
+    const hits = [];
+    for (const fromY of [around[1] + 1.5, around[1] + 3, around[1] + 6]) {
+        const res = await floorAt(grid, fromY);
+        for (const h of res ?? [])
+            if (h.surfaceY !== null && h.headroom >= 2 && h.headroom < 5.5)
+                hits.push({ x: h.x, z: h.z, y: h.surfaceY, head: h.headroom });
+    }
+    const picked = [];
+    const pool = hits.filter((h) => Math.hypot(h.x - around[0], h.z - around[2]) >= 3);
+    while (picked.length < 3 && pool.length) {
+        let best = -1;
+        let bd = -1;
+        pool.forEach((c, i) => { const d = Math.min(Math.hypot(c.x - around[0], c.z - around[2]), ...picked.map((q) => Math.hypot(c.x - q.x, c.z - q.z))); if (d > bd) {
+            bd = d;
+            best = i;
+        } });
+        if (bd < 4)
+            break;
+        picked.push(pool.splice(best, 1)[0]);
+    }
+    result.facts.interiorCandidates = { hits: hits.length, picked };
+    let n = 0;
+    for (const c of picked) {
+        n++;
+        // Look along the longest run of walkable floor from here (a room's long axis), not at the nearest wall.
+        const runs = [];
+        for (let k = 0; k < 8; k++) {
+            const a = (k / 8) * Math.PI * 2;
+            const probes = await floorAt([3, 6, 9, 12].map((r) => ({ x: c.x + Math.sin(a) * r, z: c.z + Math.cos(a) * r })), c.y + 1.2);
+            let run = 0;
+            for (const f of probes) {
+                if (f.surfaceY !== null && Math.abs(f.surfaceY - c.y) < 0.5)
+                    run++;
+                else
+                    break;
+            }
+            runs.push(run);
+        }
+        const k = runs.indexOf(Math.max(...runs));
+        const look = [c.x + Math.sin((k / 8) * Math.PI * 2) * 8, c.y + 1.4, c.z + Math.cos((k / 8) * Math.PI * 2) * 8];
+        await place([c.x, c.y + 1.5, c.z], look, 75);
+        await shoot(`scene.inside${n}`, `${title} — under cover (a ceiling ${c.head.toFixed(1)} m overhead), ${Math.hypot(c.x - around[0], c.z - around[2]).toFixed(0)} m from the spawn at floor height ${c.y.toFixed(1)} m`, 'interior');
+    }
+    await frame.evaluate(() => { window.__vqCam = null; });
+    // geometry
+    const mn = bmin;
+    const mx = bmax;
+    const overlaps = !!sb && (!mn || !mx || (sb.min[0] <= mx[0] + 5 && sb.max[0] >= mn[0] - 5 && sb.min[2] <= mx[2] + 5 && sb.max[2] >= mn[2] - 5));
+    const holdsSpawn = !!sb && !!spawn && spawn[0] >= sb.min[0] - 2 && spawn[0] <= sb.max[0] + 2 && spawn[2] >= sb.min[2] - 2 && spawn[2] <= sb.max[2] + 2;
+    const extent = sb ? Math.max(...sb.size) : 0;
+    result.asserts.push({
+        id: 'scene.bounds_plausible', pass: !!sb && overlaps && holdsSpawn && extent >= exports.MIN_SCENE_EXTENT_M && picked.length >= 1, severity: 'block',
+        detail: !sb ? 'the scene drew no measurable geometry'
+            : `the drawn scene spans ${sb.size.map((v) => v.toFixed(1)).join(' × ')} m, ${overlaps ? 'overlaps' : 'does NOT overlap'} the shell's declared bounds, ${holdsSpawn ? 'contains' : 'does NOT contain'} the spawn point, and ${picked.length} interior standpoint(s) with a floor and a ceiling 2–5.5 m overhead were found`,
+        measured: { drawn: sb, declared: { min: mn, max: mx }, spawn, interiorStandpoints: picked.length, skyScaleMeshesExcluded: stats.skyScaleMeshesExcluded },
+    });
+    result.asserts.push(...(0, commonAsserts_1.commonAsserts)('scene', stats, images, { minTriangles: 200 }));
+    result.renderer = await (0, browser_1.rendererInfo)(b.page);
+    return result;
+}
+//# sourceMappingURL=scene.js.map