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

package/dist/vehicle/cabinCheck.js

@@ -0,0 +1,799 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CABIN_CHECK_THRESHOLDS = void 0;
+exports.seatedFootPose = seatedFootPose;
+exports.seatedLegSamples = seatedLegSamples;
+exports.soupSize = soupSize;
+exports.pointTriangleDistance = pointTriangleDistance;
+exports.rayFirstHit = rayFirstHit;
+exports.classifyTriangle = classifyTriangle;
+exports.measureLimb = measureLimb;
+exports.judgeAtLeast = judgeAtLeast;
+exports.worstStatus = worstStatus;
+exports.limbRow = limbRow;
+exports.fitRows = fitRows;
+exports.legRows = legRows;
+exports.loadGlbScene = loadGlbScene;
+exports.bodySoup = bodySoup;
+exports.translateCabin = translateCabin;
+exports.checkCabin = checkCabin;
+exports.formatCabinReport = formatCabinReport;
+exports.readCabinInput = readCabinInput;
+exports.fetchPublishedCabinInput = fetchPublishedCabinInput;
+/**
+ * `helix vehicle cabin-check <dir|--item id>` — judge every seat of a car's cabin offline, in seconds, with no browser.
+ *
+ * WHY THIS EXISTS. Rear seats are the long pole of a 2+2 or a four-seater: the only judge of a rear occupant used to be the
+ * hosted visual-QA run (about 15 minutes and one of three retries per version) because the local preview room had front
+ * seats only. A blind R34 build spent about 4.7 of its 8.5 hours on that loop and wrote its own Node harness around the
+ * runtime's `fitCabinToBody` to iterate. This is that harness, generic.
+ *
+ * HOW. The runtime the platform serves is loaded as `helix vehicle simulate` does (`simulateRuntime.ts`). The GLB is read
+ * into a three.js scene (no GPU, no textures), the cabin is resolved exactly as the live spawn does
+ * (`vehicleSourceFromGltf` -> `vehiclePackageToTuning` -> `resolveVehicleCabin`, shifted into the visual's frame as
+ * `VehicleEntity.attachInterior` does) and the runtime's own `fitCabinToBody` fits it to the drawn bodywork. The fit says where
+ * each seat ends up, how much roof is over each head, and whether the driver's legs clear the wheel. On top of that this
+ * module seats the runtime's canonical legs (the same two-bone fold and cloth radii `legroom.ts` uses) at the fitted pose and
+ * measures them against every triangle of the body — which the runtime's forward rays can miss (a one-sided shell, a
+ * shin that clips the side of the seat ahead rather than its back) — and reports, per seat:
+ *
+ *   hpoint       H-point height above the floor under the feet
+ *   fit_move     how far the runtime had to move the seat from the authored H-point (the preview's `cabin_fit` gate)
+ *   head         crown clearance to the roof's inner surface
+ *   knee         knee clearance to the seat back (or dash) ahead
+ *   shin         shin and ankle clearance to what is ahead / beside them
+ *   foot         foot clearance
+ *   front_seat   the legs against the front seats' bases and backs (rear rows)
+ *   tunnel       the legs against the transmission tunnel / centre console
+ *   footwell     the room under the seat ahead: height over the foot and depth ahead of the cushion (rear rows)
+ *   driver_leg   the driver's legs against the wheel, column and dash (the runtime's own figure)
+ *
+ * Each row is PASS / WARN / FAIL with numbers; exit 1 on any FAIL. The legs are the CANONICAL body in clothes: the real
+ * avatar differs by millimetres, which is why a clearance inside a few millimetres is a WARN and only a clear intrusion
+ * a FAIL.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const vehicleCabinFit_1 = require("../visualQa/vehicleCabinFit");
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const finite = (v) => typeof v === 'number' && Number.isFinite(v);
+/** Every threshold the check judges against, metres. Exported so the report and the docs quote the same numbers. */
+exports.CABIN_CHECK_THRESHOLDS = {
+    /** H-point above the floor under the feet: below this the occupant sits on the floor (FAIL); the runtime asks for 0.34 m, a sports coupe lives near 0.2. */
+    hipAboveFloorFailM: 0.08,
+    hipAboveFloorWarnM: 0.15,
+    /** Crown to the roof lining: the same floor as the occupant gate (`headGapMinM`), warn inside 3 cm. */
+    headFailM: 0.01,
+    headWarnM: 0.03,
+    /** A seat the runtime moved (or refused): the preview's `cabin_fit` rule. */
+    fitMoveFailM: vehicleCabinFit_1.CABIN_FIT_THRESHOLDS.maxMoveM,
+    /** A canonical limb (cloth radius) deeper than this into the body is a visible clip. */
+    limbFailM: -0.015,
+    /** ...and under the daylight the runtime itself asks of every part of the leg (`LEG_CLEARANCE_M`, 15 mm) is tight enough to warn. */
+    limbWarnM: 0.015,
+    /** The driver's legs against the wheel / column / dash, the runtime's `driverLeg.clearanceM`. */
+    driverLegFailM: -0.03,
+    driverLegWarnM: 0,
+    /** The rim against the skin above it. */
+    rimFailM: 0,
+    rimWarnM: 0.02,
+    /** Free height over a planted foot under the seat ahead (the ball of the foot is 9 cm thick). */
+    footGapFailM: 0,
+    footGapWarnM: 0.02,
+    /** A mannequin leg's penetration is judged on the cloth, so the shoe sole's contact with the floor pan is not a clash. */
+    floorContactM: 0.03,
+};
+// ── the canonical seated leg (runtime `core/vehicle/legroom.ts`; the bundle does not export these) ──────────────────────
+/** Seat-local, H-point origin, +Z forward, +Y up. Measured on the canonical skeleton in the seated pose. */
+/** The canonical foot, ankle to ball, and the steepest toe-up pitch the runtime gives a seated foot (`SEATED_FOOT_PITCH_MAX_DEG`). */
+const FOOT_LENGTH_M = 0.1675;
+const FOOT_PITCH_MAX_DEG = 40;
+const LEG = { hipX: 0.1, hipY: -0.023, hipZ: 0.005, thighM: 0.4334, shinM: 0.4222, ankleRiseM: 0.1675 * 0.5, ankleBackM: 0.1675 * 0.87, toeAheadM: 0.09 };
+/** Cloth radii of the default avatar (outermost cloth vertex per bone axis). */
+const RADII = { thigh: 0.095, knee: 0.085, shin: 0.08, ankle: 0.07, ball: 0.045, toe: 0.04 };
+/** The runtime's foot-rest constants (`seats.ts`). */
+const FOOT = { restDropM: 0.3, minDropM: 0.12, soleBelowRestM: 0.02, floorContactM: 0.005, cushionForwardM: 0.4, rowBehindReachM: 0.6, spreadM: 0.11 };
+/** The seated leg for a foot rest `reachM` ahead of the H-point and `restY` under it (seat-local). Thigh samples are omitted: the thigh lies on the cushion. */
+/**
+ * The runtime's seated foot (`seats.ts` `seatedFootPose`, humanoid-character >= 0.3.214): the ankle and the ball relative to the flat
+ * foot rest (up, forward), for a foot pitched `pitchDeg` toe-up onto a toe board about its heel. Zero pitch is the flat foot.
+ */
+function seatedFootPose(pitchDeg, footLengthM = FOOT_LENGTH_M) {
+    const L = footLengthM;
+    const p = Math.min(FOOT_PITCH_MAX_DEG, Math.max(0, pitchDeg));
+    const ankleFwd = -L * 0.87;
+    if (p <= 1e-6)
+        return { ankleUp: L * 0.5, ankleFwd, ballUp: 0, ballFwd: 0 };
+    const rad = Math.PI / 180;
+    const lift = 0.51 * L * (Math.sin((125.5 - Math.min(p, 35.5)) * rad) - Math.sin(125.5 * rad));
+    const ankleUp = L * 0.5 + lift;
+    const a = (-30 + p) * rad;
+    return { ankleUp, ankleFwd, ballUp: ankleUp + L * Math.sin(a), ballFwd: ankleFwd + L * Math.cos(a) };
+}
+function seatedLegSamples(reachM, restY, pitchDeg = 0) {
+    const hy = LEG.hipY, hz = LEG.hipZ;
+    const foot = seatedFootPose(pitchDeg);
+    const ay = restY + foot.ankleUp;
+    const az = reachM + foot.ankleFwd;
+    const dy = ay - hy, dz = az - hz;
+    const d = Math.max(1e-6, Math.hypot(dy, dz));
+    const line = Math.atan2(dy, dz);
+    const reach = Math.min(d, LEG.thighM + LEG.shinM - 1e-6);
+    const cos = (LEG.thighM * LEG.thighM + reach * reach - LEG.shinM * LEG.shinM) / (2 * LEG.thighM * reach);
+    const thigh = line + Math.acos(Math.min(1, Math.max(-1, cos)));
+    const ky = hy + LEG.thighM * Math.sin(thigh);
+    const kz = hz + LEG.thighM * Math.cos(thigh);
+    const out = [{ part: 'knee', y: ky, z: kz, r: RADII.knee, t: 0 }];
+    for (const f of [0.25, 0.5, 0.75])
+        out.push({ part: 'shin', y: ky + (ay - ky) * f, z: kz + (az - kz) * f, r: RADII.shin, t: 0.5 });
+    out.push({ part: 'ankle', y: ay, z: az, r: RADII.ankle, t: 1 });
+    const by = restY + foot.ballUp, bz = reachM + foot.ballFwd;
+    const toeRad = (Math.max(0, pitchDeg) * Math.PI) / 180, toeOut = LEG.toeAheadM - RADII.toe;
+    out.push({ part: 'ball', y: by + RADII.ball - FOOT.soleBelowRestM, z: bz, r: RADII.ball, t: 1 });
+    out.push({ part: 'toe', y: by + RADII.toe - FOOT.soleBelowRestM + toeOut * Math.sin(toeRad), z: bz + toeOut * Math.cos(toeRad), r: RADII.toe, t: 1 });
+    return out;
+}
+function soupSize(s) { return s.mesh.length; }
+function triNormal(t, i) {
+    const o = i * 9;
+    const ux = t[o + 3] - t[o], uy = t[o + 4] - t[o + 1], uz = t[o + 5] - t[o + 2];
+    const wx = t[o + 6] - t[o], wy = t[o + 7] - t[o + 1], wz = t[o + 8] - t[o + 2];
+    const nx = uy * wz - uz * wy, ny = uz * wx - ux * wz, nz = ux * wy - uy * wx;
+    const l = Math.hypot(nx, ny, nz) || 1;
+    return [nx / l, ny / l, nz / l];
+}
+function triCentroid(t, i) {
+    const o = i * 9;
+    return [(t[o] + t[o + 3] + t[o + 6]) / 3, (t[o + 1] + t[o + 4] + t[o + 7]) / 3, (t[o + 2] + t[o + 5] + t[o + 8]) / 3];
+}
+/** Distance from `p` to triangle (a, b, c) — Ericson, "Real-Time Collision Detection" 5.1.5. */
+function pointTriangleDistance(p, a, b, c) {
+    const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const ac = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const ap = [p[0] - a[0], p[1] - a[1], p[2] - a[2]];
+    const dot = (u, w) => u[0] * w[0] + u[1] * w[1] + u[2] * w[2];
+    const d1 = dot(ab, ap), d2 = dot(ac, ap);
+    let q;
+    if (d1 <= 0 && d2 <= 0)
+        q = a;
+    else {
+        const bp = [p[0] - b[0], p[1] - b[1], p[2] - b[2]];
+        const d3 = dot(ab, bp), d4 = dot(ac, bp);
+        if (d3 >= 0 && d4 <= d3)
+            q = b;
+        else {
+            const vc = d1 * d4 - d3 * d2;
+            if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+                const t = d1 / (d1 - d3);
+                q = [a[0] + t * ab[0], a[1] + t * ab[1], a[2] + t * ab[2]];
+            }
+            else {
+                const cp = [p[0] - c[0], p[1] - c[1], p[2] - c[2]];
+                const d5 = dot(ab, cp), d6 = dot(ac, cp);
+                if (d6 >= 0 && d5 <= d6)
+                    q = c;
+                else {
+                    const vb = d5 * d2 - d1 * d6;
+                    if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+                        const t = d2 / (d2 - d6);
+                        q = [a[0] + t * ac[0], a[1] + t * ac[1], a[2] + t * ac[2]];
+                    }
+                    else {
+                        const va = d3 * d6 - d5 * d4;
+                        if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
+                            const t = (d4 - d3) / (d4 - d3 + (d5 - d6));
+                            q = [b[0] + t * (c[0] - b[0]), b[1] + t * (c[1] - b[1]), b[2] + t * (c[2] - b[2])];
+                        }
+                        else {
+                            const den = 1 / (va + vb + vc);
+                            const s = vb * den, t = vc * den;
+                            q = [a[0] + ab[0] * s + ac[0] * t, a[1] + ab[1] * s + ac[1] * t, a[2] + ab[2] * s + ac[2] * t];
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+}
+/** First hit of a ray (two-sided Möller–Trumbore) among the triangles `accept` allows: the distance along `dir` (unit), or null. */
+function rayFirstHit(s, origin, dir, accept, maxT = 10) {
+    let best = maxT;
+    let hit = false;
+    const t = s.tris;
+    for (let i = 0; i < s.mesh.length; i++) {
+        const o = i * 9;
+        const e1x = t[o + 3] - t[o], e1y = t[o + 4] - t[o + 1], e1z = t[o + 5] - t[o + 2];
+        const e2x = t[o + 6] - t[o], e2y = t[o + 7] - t[o + 1], e2z = t[o + 8] - t[o + 2];
+        const px = dir[1] * e2z - dir[2] * e2y, py = dir[2] * e2x - dir[0] * e2z, pz = dir[0] * e2y - dir[1] * e2x;
+        const det = e1x * px + e1y * py + e1z * pz;
+        if (Math.abs(det) < 1e-12)
+            continue;
+        const inv = 1 / det;
+        const tx = origin[0] - t[o], ty = origin[1] - t[o + 1], tz = origin[2] - t[o + 2];
+        const u = (tx * px + ty * py + tz * pz) * inv;
+        if (u < 0 || u > 1)
+            continue;
+        const qx = ty * e1z - tz * e1y, qy = tz * e1x - tx * e1z, qz = tx * e1y - ty * e1x;
+        const v = (dir[0] * qx + dir[1] * qy + dir[2] * qz) * inv;
+        if (v < 0 || u + v > 1)
+            continue;
+        const d = (e2x * qx + e2y * qy + e2z * qz) * inv;
+        if (d <= 1e-6 || d >= best)
+            continue;
+        if (accept && !accept(i))
+            continue;
+        best = d;
+        hit = true;
+    }
+    return hit ? best : null;
+}
+/** Class of a triangle relative to the occupant at `self`: inside the footprint of a seat in an earlier row (and not above its head), else a lateral wall near the centre line, else other. Pure. */
+function classifyTriangle(centroid, normal, self, seats) {
+    for (const s of seats) {
+        if (s.row >= self.row)
+            continue;
+        if (Math.abs(centroid[0] - s.hip[0]) <= 0.3 && centroid[2] >= s.hip[2] - 0.6 && centroid[2] <= s.hip[2] + 0.5 && centroid[1] <= s.hip[1] + 0.8)
+            return { cls: 'front_seat', seat: s.id };
+    }
+    if (Math.abs(centroid[0]) <= 0.3 && Math.abs(normal[0]) > 0.5)
+        return { cls: 'tunnel' };
+    return { cls: 'other' };
+}
+/**
+ * Distance of one limb sphere to the body, per class. Surfaces the sphere stands on are not clashes: a roughly horizontal
+ * triangle at or under the sphere's middle is the floor, a sill or a cushion it rests on (the foot IK plants the sole on the
+ * floor; the canonical leg and the drawn floor differ by a centimetre or two). Triangles inside the occupant's own seat
+ * (cushion, back, base) are skipped for the same reason.
+ */
+function measureLimb(s, p, r, self, seats, ownSeat) {
+    const best = { front_seat: Infinity, tunnel: Infinity, other: Infinity };
+    let bestAny = Infinity;
+    let mesh = null;
+    let against = null;
+    let againstSeat = null;
+    const t = s.tris;
+    for (let i = 0; i < s.mesh.length; i++) {
+        const o = i * 9;
+        // cheap reject: the triangle's box against the sphere's reach
+        const reach = Math.min(1, Math.max(best.front_seat, best.tunnel, best.other));
+        const lo = (a, b, c) => Math.min(a, b, c);
+        const hi = (a, b, c) => Math.max(a, b, c);
+        if (p[0] < lo(t[o], t[o + 3], t[o + 6]) - reach || p[0] > hi(t[o], t[o + 3], t[o + 6]) + reach)
+            continue;
+        if (p[1] < lo(t[o + 1], t[o + 4], t[o + 7]) - reach || p[1] > hi(t[o + 1], t[o + 4], t[o + 7]) + reach)
+            continue;
+        if (p[2] < lo(t[o + 2], t[o + 5], t[o + 8]) - reach || p[2] > hi(t[o + 2], t[o + 5], t[o + 8]) + reach)
+            continue;
+        const n = triNormal(t, i);
+        const c = triCentroid(t, i);
+        if (Math.abs(n[1]) > 0.7 && c[1] < p[1] + exports.CABIN_CHECK_THRESHOLDS.floorContactM)
+            continue;
+        if (ownSeat(c))
+            continue;
+        const d = pointTriangleDistance(p, [t[o], t[o + 1], t[o + 2]], [t[o + 3], t[o + 4], t[o + 5]], [t[o + 6], t[o + 7], t[o + 8]]);
+        const k = classifyTriangle(c, n, self, seats);
+        if (d < best[k.cls])
+            best[k.cls] = d;
+        if (d < bestAny) {
+            bestAny = d;
+            mesh = s.mesh[i];
+            against = k.cls;
+            againstSeat = k.seat ?? null;
+        }
+    }
+    const sub = (d) => (Number.isFinite(d) ? d - r : Infinity);
+    return {
+        clearanceM: sub(bestAny),
+        byClass: { front_seat: sub(best.front_seat), tunnel: sub(best.tunnel), other: sub(best.other) },
+        mesh: mesh === null ? null : s.names[mesh] ?? null,
+        against,
+        againstSeat,
+    };
+}
+const mm = (m) => `${Math.round(m * 1000)} mm`;
+const fmt = (v) => `[${v.map((x) => (Math.abs(x) < 5e-4 ? 0 : x).toFixed(3)).join(', ')}]`;
+/** Higher is better: FAIL below `fail`, WARN below `warn`. */
+function judgeAtLeast(valueM, fail, warn) {
+    return valueM < fail ? 'FAIL' : valueM < warn ? 'WARN' : 'PASS';
+}
+function worstStatus(statuses) {
+    if (statuses.includes('FAIL'))
+        return 'FAIL';
+    if (statuses.includes('WARN'))
+        return 'WARN';
+    if (statuses.every((s) => s === 'NOT_MEASURED'))
+        return 'NOT_MEASURED';
+    return 'PASS';
+}
+/** Judge a set of limb readings as one row (`id`), named for what they are closest to. */
+function limbRow(id, label, readings, pick, named) {
+    const T = exports.CABIN_CHECK_THRESHOLDS;
+    const th = `${label} clears the body by >= ${mm(T.limbWarnM)} (WARN under it, FAIL more than ${mm(-T.limbFailM)} inside)`;
+    const rows = readings.map((r) => ({ r, c: pick(r) })).filter((x) => Number.isFinite(x.c));
+    if (!rows.length)
+        return { id, status: 'PASS', valueM: null, detail: `nothing within reach of the ${label}`, threshold: th };
+    const worst = rows.reduce((a, b) => (b.c < a.c ? b : a));
+    const status = judgeAtLeast(worst.c, T.limbFailM, T.limbWarnM);
+    const what = named ? named(worst.r) : worst.r.againstSeat ? `the seat ahead (${worst.r.againstSeat})` : worst.r.against === 'tunnel' ? 'the tunnel / centre console' : `bodywork${worst.r.mesh ? ` (${worst.r.mesh})` : ''}`;
+    const detail = worst.c < 0
+        ? `${worst.r.side === 'l' ? 'left' : 'right'} ${worst.r.part} is ${mm(-worst.c)} INSIDE ${what} at ${fmt(worst.r.at)}`
+        : `${worst.r.side === 'l' ? 'left' : 'right'} ${worst.r.part} clears ${what} by ${mm(worst.c)} at ${fmt(worst.r.at)}`;
+    return { id, status, valueM: worst.c, detail, threshold: th };
+}
+/** The non-geometric rows of a seat, from the runtime's fit. Pure. */
+function fitRows(f) {
+    const T = exports.CABIN_CHECK_THRESHOLDS;
+    const rows = [];
+    if (f.hipAboveFloorM === null) {
+        rows.push({ id: 'hpoint', status: 'NOT_MEASURED', valueM: null, detail: 'no floor was found under the seat', threshold: `H-point >= ${mm(T.hipAboveFloorWarnM)} above the floor` });
+    }
+    else {
+        rows.push({
+            id: 'hpoint', status: judgeAtLeast(f.hipAboveFloorM, T.hipAboveFloorFailM, T.hipAboveFloorWarnM), valueM: f.hipAboveFloorM,
+            detail: `H-point ${fmt(f.hip)}, ${mm(f.hipAboveFloorM)} above the floor under the feet${f.measured ? '' : ' (DERIVED from the hull, not authored: add a seat_* socket)'}`,
+            threshold: `H-point >= ${mm(T.hipAboveFloorWarnM)} above the floor (WARN under, FAIL under ${mm(T.hipAboveFloorFailM)}); the runtime's seating package asks for 340 mm, a sports coupe sits near 200 mm`,
+        });
+    }
+    const move = Math.hypot(f.movedAftM, f.loweredM);
+    const moveStatus = !f.accepted || move > T.fitMoveFailM ? 'FAIL' : 'PASS';
+    rows.push({
+        id: 'fit_move', status: moveStatus, valueM: move,
+        detail: !f.accepted ? `the runtime REFUSED this seat: ${f.reason ?? 'no reason given'}`
+            : `the runtime's fit moved this seat ${mm(move)} (${mm(f.movedAftM)} aft, ${mm(f.loweredM)} lowered)${move > T.fitMoveFailM && f.authoredHip ? `; declare ${fmt(f.hip)} if that is where it belongs, or open the cabin around ${fmt(f.authoredHip)}` : ''}`,
+        threshold: `the fit moves the seat <= ${mm(T.fitMoveFailM)} from its authored H-point and refuses none`,
+    });
+    if (f.crownClearanceM === null) {
+        rows.push({ id: 'head', status: 'PASS', valueM: null, detail: 'no roof over this seat (open car)', threshold: `crown >= ${mm(T.headWarnM)} under the roof lining` });
+    }
+    else {
+        rows.push({
+            id: 'head', status: judgeAtLeast(f.crownClearanceM, T.headFailM, T.headWarnM), valueM: f.crownClearanceM,
+            detail: `crown ${mm(f.crownClearanceM)} under the roof's inner surface (${f.headroomM === null ? '?' : mm(f.headroomM)} of roof over the H-point)${f.occupantMeasured ? '' : ', against the runtime\'s derived occupant'}`,
+            threshold: `crown >= ${mm(T.headWarnM)} under the roof lining (WARN under, FAIL under ${mm(T.headFailM)})`,
+        });
+    }
+    if (f.driverLeg) {
+        const c = f.driverLeg.clearanceM;
+        rows.push({
+            id: 'driver_leg', status: judgeAtLeast(c, T.driverLegFailM, T.driverLegWarnM), valueM: c,
+            detail: `${c < 0 ? `driver's ${f.driverLeg.part ?? 'leg'} is ${mm(-c)} INTO the ${f.driverLeg.against ?? 'cabin'}` : `driver's ${f.driverLeg.part ?? 'leg'} clears the ${f.driverLeg.against ?? 'cabin'} by ${mm(c)}`}${f.driverLeg.limitedBy ? ` (the seat track stops at: ${f.driverLeg.limitedBy})` : ''}`,
+            threshold: `driver's thighs, knees and shins clear the wheel, column and dash (WARN under 0, FAIL more than ${mm(-T.driverLegFailM)} inside)`,
+        });
+    }
+    return rows;
+}
+/** The leg rows of a passenger seat from its readings. Pure over the readings. */
+function legRows(readings, hasSeatAhead) {
+    const rows = [];
+    const of = (parts) => readings.filter((r) => parts.includes(r.part));
+    rows.push(limbRow('knee', 'knee', of(['knee']), (r) => r.clearanceM));
+    rows.push(limbRow('shin', 'shin and ankle', of(['shin', 'ankle']), (r) => r.clearanceM));
+    rows.push(limbRow('foot', 'foot', of(['ball', 'toe']), (r) => r.clearanceM));
+    if (hasSeatAhead)
+        rows.push(limbRow('front_seat', 'legs against the seat ahead', readings, (r) => r.byClass.front_seat, () => 'the seat ahead (its base or back)'));
+    rows.push(limbRow('tunnel', 'legs against the tunnel / console', readings, (r) => r.byClass.tunnel, () => 'the tunnel / centre console'));
+    return rows;
+}
+// ── scene, cabin and runtime ─────────────────────────────────────────────────────────────────────────────────────────────
+const WHEEL_NODE = /(^|[_\-.])(rim|wheel|whl|tyre|tire|brake[_-]?disc|caliper)([_\-.\d]|$)/i;
+/** Read a GLB into a three.js scene (geometry and node transforms only): no GPU, no textures. */
+async function loadGlbScene(glb, THREE) {
+    const { NodeIO } = await Promise.resolve().then(() => __importStar(require('@gltf-transform/core')));
+    const { ALL_EXTENSIONS } = await Promise.resolve().then(() => __importStar(require('@gltf-transform/extensions')));
+    const { importEsm } = await Promise.resolve().then(() => __importStar(require('../character/esm')));
+    const meshopt = await importEsm('meshoptimizer');
+    await meshopt.MeshoptDecoder.ready;
+    const io = new NodeIO().registerExtensions(ALL_EXTENSIONS).registerDependencies({ 'meshopt.decoder': meshopt.MeshoptDecoder });
+    const bytes = new Uint8Array(glb.buffer, glb.byteOffset, glb.byteLength);
+    const jsonDoc = await io.binaryToJSON(bytes);
+    const doc = await io.readJSON(jsonDoc);
+    const scene = new THREE.Group();
+    const exclude = [];
+    const build = (node) => {
+        const o = new THREE.Object3D();
+        o.name = node.getName();
+        const mesh = node.getMesh();
+        if (mesh) {
+            for (const prim of mesh.listPrimitives()) {
+                const pos = prim.getAttribute('POSITION');
+                if (!pos)
+                    continue;
+                const n = pos.getCount();
+                const arr = new Float32Array(n * 3);
+                const el = [0, 0, 0];
+                for (let i = 0; i < n; i++) {
+                    pos.getElement(i, el);
+                    arr[i * 3] = el[0];
+                    arr[i * 3 + 1] = el[1];
+                    arr[i * 3 + 2] = el[2];
+                }
+                const g = new THREE.BufferGeometry();
+                g.setAttribute('position', new THREE.BufferAttribute(arr, 3));
+                const idx = prim.getIndices();
+                if (idx)
+                    g.setIndex(new THREE.BufferAttribute(new Uint32Array(idx.getArray()), 1));
+                const m = new THREE.Mesh(g, new THREE.MeshBasicMaterial({ side: THREE.DoubleSide }));
+                m.name = node.getName();
+                o.add(m);
+            }
+        }
+        o.position.fromArray(node.getTranslation());
+        o.quaternion.fromArray(node.getRotation());
+        o.scale.fromArray(node.getScale());
+        for (const c of node.listChildren())
+            o.add(build(c));
+        if (WHEEL_NODE.test(o.name))
+            exclude.push(o);
+        return o;
+    };
+    for (const n of doc.getRoot().getDefaultScene()?.listChildren() ?? doc.getRoot().listScenes()[0]?.listChildren() ?? [])
+        scene.add(build(n));
+    const root = new THREE.Group();
+    root.add(scene);
+    return { root, scene, json: jsonDoc.json, exclude };
+}
+/** The body's triangles in the cabin frame, wheels left out (the runtime's fit excludes its wheel nodes the same way). */
+function bodySoup(THREE, root, exclude) {
+    root.updateMatrixWorld(true);
+    const skip = new Set(exclude);
+    const meshes = []; // eslint-disable-line @typescript-eslint/no-explicit-any
+    root.traverse((o) => {
+        if (!o.isMesh)
+            return;
+        for (let p = o; p; p = p.parent)
+            if (skip.has(p))
+                return;
+        meshes.push(o);
+    });
+    let count = 0;
+    for (const m of meshes) {
+        const idx = m.geometry.getIndex();
+        count += Math.floor((idx ? idx.count : m.geometry.getAttribute('position').count) / 3);
+    }
+    const tris = new Float32Array(count * 9);
+    const mesh = new Uint16Array(count);
+    const names = [];
+    const v = new THREE.Vector3();
+    let t = 0;
+    meshes.forEach((m, mi) => {
+        names.push(m.name || `mesh${mi}`);
+        const pos = m.geometry.getAttribute('position');
+        const idx = m.geometry.getIndex();
+        const n = Math.floor((idx ? idx.count : pos.count) / 3);
+        for (let i = 0; i < n; i++) {
+            for (let k = 0; k < 3; k++) {
+                v.fromBufferAttribute(pos, idx ? idx.getX(i * 3 + k) : i * 3 + k).applyMatrix4(m.matrixWorld);
+                tris[t * 9 + k * 3] = v.x;
+                tris[t * 9 + k * 3 + 1] = v.y;
+                tris[t * 9 + k * 3 + 2] = v.z;
+            }
+            mesh[t++] = mi;
+        }
+    });
+    return { tris, mesh, names };
+}
+/** What `VehicleEntity.attachInterior` does when the drawn model is not where the descriptor's nominal frame puts it. */
+function translateCabin(cabin, delta) {
+    const move = (p) => (Array.isArray(p) ? [p[0] + delta[0], p[1] + delta[1], p[2] + delta[2]] : p);
+    const pedal = (p) => (isRecord(p) ? { ...p, pad: move(p.pad), hinge: move(p.hinge) } : p);
+    const seats = Array.isArray(cabin.seats) ? cabin.seats.map((s) => {
+        const seat = s;
+        const ff = seat.footFloor;
+        return { ...seat, hipPoint: move(seat.hipPoint), exitPoint: move(seat.exitPoint), ...(isRecord(ff) ? { footFloor: { l: ff.l + delta[1], r: ff.r + delta[1] } } : {}) };
+    }) : cabin.seats;
+    const pedals = isRecord(cabin.pedals) ? Object.fromEntries(Object.entries(cabin.pedals).map(([k, v]) => [k, pedal(v)])) : cabin.pedals;
+    return {
+        ...cabin, seats, pedals,
+        ...(isRecord(cabin.steering) ? { steering: { ...cabin.steering, centre: move(cabin.steering.centre) } } : {}),
+        ...(cabin.gearshift !== undefined ? { gearshift: move(cabin.gearshift) } : {}),
+        ...(cabin.ignition !== undefined ? { ignition: move(cabin.ignition) } : {}),
+        ...(finite(cabin.floorY) ? { floorY: cabin.floorY + delta[1] } : {}),
+    };
+}
+const seatIdOk = /^seat_(dside|pside)_(f|r\d+)$/;
+function declaredSeatIds(pkg, cabinSeatIds, engine) {
+    const spec = isRecord(pkg.specialty) ? pkg.specialty : null;
+    const mod = spec && isRecord(spec.module) ? spec.module : null;
+    const out = new Set();
+    const seatVars = mod && isRecord(mod.seatVars) ? mod.seatVars : null;
+    if (!seatVars) {
+        // A package with no specialty has the platform default control manifest: let the runtime say which seats it grants.
+        try {
+            const manifest = engine.vehicleControlManifest?.(pkg);
+            const sv = manifest?.manifest.module.seatVars ?? {};
+            const driver = manifest?.manifest.module.driverSeat ?? 'driver';
+            for (const k of Object.keys(sv)) {
+                if (seatIdOk.test(k))
+                    out.add(k);
+                else if (k === driver)
+                    out.add('seat_dside_f');
+                else if (k === 'passenger' && cabinSeatIds.includes('seat_pside_f'))
+                    out.add('seat_pside_f');
+            }
+        }
+        catch { /* an engine without it: every cabin seat is judged */
+            cabinSeatIds.forEach((s) => out.add(s));
+        }
+        return out;
+    }
+    const driverKey = typeof mod?.driverSeat === 'string' ? mod.driverSeat : 'driver';
+    for (const k of Object.keys(seatVars)) {
+        if (seatIdOk.test(k))
+            out.add(k);
+        else if (k === driverKey)
+            out.add('seat_dside_f');
+        else if (k === 'passenger') {
+            const p = cabinSeatIds.find((s) => s !== 'seat_dside_f' && /_f$/.test(s));
+            if (p)
+                out.add(p);
+        }
+    }
+    return out;
+}
+/** Run the check. Throws only when the runtime cannot resolve the car at all (the package or model is unreadable). */
+async function checkCabin(input, runtime) {
+    const t0 = Date.now();
+    const E = runtime.engine;
+    for (const name of ['vehicleSourceFromGltf', 'vehiclePackageToTuning', 'resolveVehicleCabin', 'fitCabinToBody', 'modelToBody']) {
+        if (typeof E[name] !== 'function')
+            throw new Error(`the engine runtime ${runtime.info.version} does not export ${name}; update @helix3/helix-cli`);
+    }
+    const { localEngineDeps, runtimeCacheDir } = await Promise.resolve().then(() => __importStar(require('./simulateRuntime')));
+    const { importEsm } = await Promise.resolve().then(() => __importStar(require('../character/esm')));
+    const THREE = await importEsm(localEngineDeps(runtimeCacheDir()).map.three); // eslint-disable-line @typescript-eslint/no-explicit-any
+    const loaded = await loadGlbScene(input.glb, THREE);
+    const pkg = input.pkg;
+    const source = E.vehicleSourceFromGltf({ scene: loaded.scene, parser: { json: loaded.json } });
+    const resolved = E.vehiclePackageToTuning(pkg, { source, landSolver: 'v2' });
+    const cabin0 = E.resolveVehicleCabin(resolved.descriptor);
+    // The live spawn parks the model at `visualOffset`; the descriptor's nominal frame differs when the package's ride height is not the class preset's.
+    loaded.scene.position.set(...resolved.visualOffset);
+    const nominal = E.modelToBody(resolved.descriptor)([0, 0, 0]);
+    const delta = [resolved.visualOffset[0] - nominal[0], resolved.visualOffset[1] - nominal[1], resolved.visualOffset[2] - nominal[2]];
+    const framed = Math.abs(delta[0]) > 1e-6 || Math.abs(delta[1]) > 1e-6 || Math.abs(delta[2]) > 1e-6 ? translateCabin(cabin0, delta) : cabin0;
+    // Newer runtimes name the car's own drawn steering wheel so the fit does not count it as dash (`drawnControlNodes`, humanoid-character >= 0.3.209);
+    // an older one does not export it and the wheel stays among the bodywork, exactly as that runtime's live spawn treats it.
+    const drawnWheel = typeof E.drawnControlNodes === 'function' ? E.drawnControlNodes('steering', { modelRoot: loaded.scene, descriptor: resolved.descriptor }) : [];
+    const fitExclude = [...loaded.exclude, ...drawnWheel];
+    const fit = E.fitCabinToBody(framed, loaded.root, { exclude: fitExclude });
+    if (!fit.report.measured)
+        throw new Error('the runtime found no bodywork geometry to fit the cabin to (is the GLB empty, or are all its meshes under wheel-named nodes?)');
+    const soup = bodySoup(THREE, loaded.root, fitExclude);
+    const cabinSeatIds = cabin0.seats.map((s) => s.id);
+    const declared = declaredSeatIds(pkg, cabinSeatIds, E);
+    const zones = fit.cabin.seats.map((s) => ({ id: s.id, row: s.row, hip: s.hipPoint }));
+    const seatsAuthored = new Map(cabin0.seats.map((s) => [s.id, s.hipPoint]));
+    const footFwd = E.SEATED_FOOT_FORWARD_M ?? 0.84;
+    const footMin = Math.max(E.SEATED_FOOT_MIN_FORWARD_M ?? 0.32, FOOT.cushionForwardM);
+    const seats = [];
+    for (const seat of fit.cabin.seats) {
+        const f = fit.report.seats.find((x) => x.id === seat.id);
+        const isDeclared = declared.has(seat.id);
+        const hp = seat.hipPoint;
+        if (!f) {
+            seats.push({ id: seat.id, role: seat.role, row: seat.row, declared: isDeclared, hPoint: hp, status: 'SKIPPED', rows: [], note: 'the runtime refused this seat (no fit entry)' });
+            continue;
+        }
+        if (!isDeclared) {
+            seats.push({ id: seat.id, role: seat.role, row: seat.row, declared: false, hPoint: hp, status: 'SKIPPED', rows: [], note: 'the cabin has this seat but the package does not declare it (specialty.module.seatVars): nobody can board it, so it is not judged' });
+            continue;
+        }
+        const floors = seat.footFloor ? [seat.footFloor.l, seat.footFloor.r] : [];
+        const floor = floors.length ? Math.min(...floors) : null;
+        const facts = {
+            id: seat.id, role: seat.role, row: seat.row, declared: true, measured: seat.measured !== false, hip: hp, authoredHip: (() => { const a = seatsAuthored.get(seat.id); return a ? [a[0] + delta[0], a[1] + delta[1], a[2] + delta[2]] : null; })(),
+            accepted: f.accepted, reason: f.reason, movedAftM: f.movedAft, loweredM: f.lowered,
+            hipAboveFloorM: floor === null ? null : hp[1] - floor, crownClearanceM: f.crownClearance, headroomM: f.headroom, occupantMeasured: f.occupantMeasured,
+            driverLeg: f.driverLeg ?? null, legroom: f.legroom ?? null,
+        };
+        const rows = fitRows(facts);
+        if (seat.role !== 'driver') {
+            const stated = fit.cabin.footwellForwardM;
+            const derived = stated === undefined ? (seat.row > 0 ? FOOT.rowBehindReachM : footFwd) : Math.min(footFwd, Math.max(footMin, stated));
+            const reach = seat.footReachM !== undefined ? Math.min(footFwd, Math.max(footMin, seat.footReachM)) : derived;
+            const scale = fit.cabin.scale ?? 1;
+            const readings = [];
+            for (const side of ['l', 'r']) {
+                const sign = side === 'l' ? 1 : -1;
+                const floorY = seat.footFloor?.[side];
+                const rest = Math.min(Math.max(-FOOT.restDropM, floorY === undefined ? -FOOT.restDropM : floorY + FOOT.soleBelowRestM + FOOT.floorContactM - hp[1]), -FOOT.minDropM) + (seat.footRiseM ?? 0);
+                const hipX = hp[0] + sign * LEG.hipX;
+                // the runtime's `footLateralShift`: the outboard foot moves the whole `footShiftM` toward the centreline, the inboard one half
+                const shift = seat.footShiftM ?? 0;
+                const footX = hp[0] + sign * FOOT.spreadM * scale + (shift === 0 ? 0 : sign * Math.sign(hp[0]) > 0 ? shift : shift / 2);
+                const own = (c) => Math.abs(c[0] - hp[0]) < 0.3 && c[2] <= hp[2] + FOOT.cushionForwardM && c[2] >= hp[2] - 0.6 && c[1] >= hp[1] - 0.3;
+                for (const s of seatedLegSamples(reach, rest, seat.footPitchDeg ?? 0)) {
+                    const p = [hipX + (footX - hipX) * s.t, hp[1] + s.y, hp[2] + s.z];
+                    const m = measureLimb(soup, p, s.r, { id: seat.id, row: seat.row, hip: hp }, zones, own);
+                    readings.push({ part: s.part, side, at: p, ...m });
+                }
+            }
+            const ahead = zones.some((z) => z.row < seat.row);
+            rows.push(...legRows(readings, ahead));
+            if (seat.row > 0 && ahead)
+                rows.push(footwellRow(soup, hp, reach, readings));
+        }
+        seats.push({ id: seat.id, role: seat.role, row: seat.row, declared: true, hPoint: hp, status: worstStatus(rows.map((r) => r.status)), rows });
+    }
+    const steeringFit = fit.report.steering;
+    const steering = steeringFit && steeringFit.worstClearance !== null && Number.isFinite(steeringFit.worstClearance)
+        ? (() => {
+            const c = steeringFit.worstClearance;
+            return { worstClearanceM: c, status: judgeAtLeast(c, exports.CABIN_CHECK_THRESHOLDS.rimFailM, exports.CABIN_CHECK_THRESHOLDS.rimWarnM), detail: c < 0 ? `the wheel rim is ${mm(-c)} outside the skin above it` : `the wheel rim clears the skin above it by ${mm(c)}` };
+        })()
+        : null;
+    const statuses = [...seats.flatMap((s) => s.rows.map((r) => r.status)), ...(steering ? [steering.status] : [])];
+    const notes = [];
+    const undeclared = seats.filter((s) => s.status === 'SKIPPED');
+    if (undeclared.length)
+        notes.push(`${undeclared.map((s) => s.id).join(', ')} ${undeclared.length === 1 ? 'is' : 'are'} in the cabin but not declared in the package's seat table, so ${undeclared.length === 1 ? 'it is' : 'they are'} not judged`);
+    if (!seats.some((s) => s.status !== 'SKIPPED'))
+        notes.push('no declared seat could be judged');
+    const triangles = soupSize(soup);
+    return {
+        ok: !statuses.includes('FAIL'),
+        exitCode: statuses.includes('FAIL') ? 1 : 0,
+        engine: { version: runtime.info.version, source: runtime.info.source },
+        glb: { bytes: input.glb.length, triangles },
+        car: typeof pkg.displayName === 'string' ? pkg.displayName : input.name ?? null,
+        seats, steering,
+        runtimeWarnings: [...fit.report.warnings],
+        notes, millis: Date.now() - t0,
+    };
+}
+/** Free height over the floor under the seat ahead, scanned from the rear cushion's face to the toe: how far the foot goes under, and how much room is left over it. */
+function footwellRow(soup, hp, reach, readings) {
+    const T = exports.CABIN_CHECK_THRESHOLDS;
+    const th = `a rear foot that goes under the seat ahead keeps >= ${mm(T.footGapWarnM)} of free height over the ball of the foot (WARN under, FAIL at contact)`;
+    const own = (c) => Math.abs(c[0] - hp[0]) < 0.3 && c[2] <= hp[2] + FOOT.cushionForwardM && c[2] >= hp[2] - 0.6 && c[1] >= hp[1] - 0.3;
+    const notOwnNotFloor = (i) => !own(triCentroid(soup.tris, i)) && triNormal(soup.tris, i)[1] < 0.5;
+    const footH = 2 * RADII.ball;
+    let gap = Infinity;
+    let gapAt = null;
+    let under = 0;
+    for (const r of readings.filter((x) => x.part === 'ball')) {
+        const sole = r.at[1] - RADII.ball;
+        const toeZ = hp[2] + reach + LEG.toeAheadM;
+        let startZ = null;
+        for (let z = hp[2] + FOOT.cushionForwardM; z <= toeZ + 1e-9; z += 0.02) {
+            const up = rayFirstHit(soup, [r.at[0], sole + 0.01, z], [0, 1, 0], notOwnNotFloor, 1.5);
+            const free = up === null ? Infinity : up + 0.01;
+            if (free < 0.45 && startZ === null)
+                startZ = z;
+            if (startZ !== null && free - footH < gap) {
+                gap = free - footH;
+                gapAt = [r.at[0], sole, z];
+            }
+        }
+        if (startZ !== null)
+            under = Math.max(under, toeZ - startZ);
+    }
+    const status = under === 0 || !Number.isFinite(gap) ? 'PASS' : judgeAtLeast(gap, T.footGapFailM, T.footGapWarnM);
+    const detail = under === 0
+        ? 'the feet stay clear of the seat ahead (nothing within 450 mm over the floor in front of the cushion)'
+        : `the foot goes ${mm(under)} under the seat ahead, leaving ${mm(gap)} over the ball of the foot at its tightest${gapAt ? ` (${fmt(gapAt)})` : ''}`;
+    return { id: 'footwell', status, valueM: under === 0 ? null : gap, detail, threshold: th };
+}
+// ── report ────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+function formatCabinReport(r) {
+    const L = [];
+    L.push(`${r.ok ? '✔' : '✖'} cabin check ${r.ok ? (r.seats.some((s) => s.status === 'WARN') ? 'PASS with warnings' : 'PASS') : 'FAIL'}${r.car ? ` — ${r.car}` : ''}`);
+    L.push(`  engine runtime ${r.engine.version} (${r.engine.source}); ${r.glb.triangles} triangles read; ${r.millis} ms; z+ is forward, metres in the body frame`);
+    for (const s of r.seats) {
+        L.push('');
+        L.push(`${s.status === 'SKIPPED' ? '-' : s.status === 'PASS' ? '✔' : s.status === 'WARN' ? '⚠' : '✖'} ${s.id} (${s.role}, row ${s.row}) ${s.status}  H-point ${fmt(s.hPoint)}`);
+        if (s.note)
+            L.push(`    ${s.note}`);
+        for (const row of s.rows)
+            L.push(`    ${row.status.padEnd(12)} ${row.id.padEnd(11)} ${row.detail}`);
+    }
+    if (r.steering)
+        L.push('', `${r.steering.status === 'PASS' ? '✔' : r.steering.status === 'WARN' ? '⚠' : '✖'} steering wheel ${r.steering.status}: ${r.steering.detail}`);
+    if (r.notes.length) {
+        L.push('');
+        for (const n of r.notes)
+            L.push(`note: ${n}`);
+    }
+    const bad = r.seats.flatMap((s) => s.rows.filter((x) => x.status === 'FAIL' || x.status === 'WARN').map((x) => ({ s, x })));
+    if (bad.length) {
+        L.push('', 'thresholds judged against:');
+        for (const t of [...new Set(bad.map((b) => `  ${b.x.id}: ${b.x.threshold}`))])
+            L.push(t);
+        L.push('fix: reshape the seat, floor, console or tunnel in the model (or move the seat_* socket) and re-run; then confirm with `helix vehicle preview <dir> --occupants`.');
+    }
+    if (r.runtimeWarnings.length) {
+        L.push('', 'the runtime\'s own cabin-fit warnings:');
+        for (const w of r.runtimeWarnings)
+            L.push(`  ${w}`);
+    }
+    return L.join('\n');
+}
+/** Read a package directory (`vehicle-package.json` + `model.glb`, or the one `.glb`) or a package JSON beside its model. */
+function readCabinInput(dirOrPackage, glbOverride) {
+    const path = (0, node_path_1.resolve)(dirOrPackage);
+    if (!(0, node_fs_1.existsSync)(path))
+        throw new Error(`${path} does not exist`);
+    const isDir = (0, node_fs_1.statSync)(path).isDirectory();
+    const dir = isDir ? path : (0, node_path_1.dirname)(path);
+    const packageFile = isDir ? ['vehicle-package.json', 'vehicle.package.json', 'package.vehicle.json'].map((f) => (0, node_path_1.join)(dir, f)).find(node_fs_1.existsSync) : path;
+    if (!packageFile)
+        throw new Error(`${dir} has no vehicle-package.json`);
+    let glbFile = glbOverride ? (0, node_path_1.resolve)(glbOverride) : undefined;
+    if (!glbFile) {
+        const glbs = (0, node_fs_1.readdirSync)(dir).filter((f) => f.toLowerCase().endsWith('.glb'));
+        if (glbs.includes('model.glb'))
+            glbFile = (0, node_path_1.join)(dir, 'model.glb');
+        else if (glbs.length === 1)
+            glbFile = (0, node_path_1.join)(dir, glbs[0]);
+        else
+            throw new Error(glbs.length === 0 ? `${dir} has no .glb model (pass --glb)` : `${dir} has ${glbs.length} .glb files; name the drawn one model.glb or pass --glb`);
+    }
+    return { pkg: JSON.parse((0, node_fs_1.readFileSync)(packageFile, 'utf8')), glb: (0, node_fs_1.readFileSync)(glbFile), dir, packageFile, glbFile };
+}
+/** A published vehicle's package and drawn model (public reads; the CDN refuses a bare client, so the request carries a browser user agent). */
+async function fetchPublishedCabinInput(apiUrl, itemId, fetchImpl = fetch) {
+    const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0 Safari/537.36 helix-cli';
+    const base = apiUrl.replace(/\/$/, '');
+    let res = await fetchImpl(`${base}/api/v1/universal-items/${encodeURIComponent(itemId)}`, { headers: { accept: 'application/json', 'user-agent': UA } });
+    for (let attempt = 1; res.status >= 500 && attempt < 4; attempt += 1) {
+        await new Promise((done) => setTimeout(done, 1000 * attempt));
+        res = await fetchImpl(`${base}/api/v1/universal-items/${encodeURIComponent(itemId)}`, { headers: { accept: 'application/json', 'user-agent': UA } });
+    }
+    if (!res.ok)
+        throw new Error(`GET /api/v1/universal-items/${itemId} answered HTTP ${res.status}`);
+    const body = await res.json();
+    const item = (isRecord(body.item) ? body.item : body);
+    const props = isRecord(item.properties) ? item.properties : {};
+    const pkg = props.vehiclePackage;
+    if (!isRecord(pkg))
+        throw new Error(`item ${itemId} carries no properties.vehiclePackage (is it a vehicle?)`);
+    const mesh = isRecord(pkg.mesh) ? pkg.mesh : {};
+    const visual = isRecord(mesh.visual) ? mesh.visual : {};
+    const renditions = Array.isArray(visual.renditions) ? visual.renditions.filter(isRecord) : [];
+    // The drawn model: the source rendition when it is materialised, else the derived web rendition the runtime loads.
+    const fromRenditions = [...renditions.filter((r) => r.kind === 'source'), ...renditions.filter((r) => r.kind !== 'source')].map((r) => r.artifactRef).find((u) => typeof u === 'string' && u.length > 0);
+    const assets = Array.isArray(item.assets) ? item.assets.filter(isRecord) : [];
+    const fromAssets = ['web', 'mesh'].map((k) => assets.find((a) => a.rendition === k && typeof a.cdnUrl === 'string')?.cdnUrl).find((u) => typeof u === 'string');
+    const modelUrl = fromRenditions ?? fromAssets;
+    if (!modelUrl)
+        throw new Error(`item ${itemId} names no model URL (package.mesh.visual.renditions[].artifactRef, or a web/mesh asset)`);
+    const glbRes = await fetchImpl(modelUrl, { headers: { 'user-agent': UA }, redirect: 'follow' });
+    if (!glbRes.ok)
+        throw new Error(`could not download the model ${modelUrl}: HTTP ${glbRes.status}`);
+    return { pkg, glb: Buffer.from(await glbRes.arrayBuffer()), name: typeof item.title === 'string' ? item.title : itemId, modelUrl };
+}
+//# sourceMappingURL=cabinCheck.js.map