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

package/dist/visualQa/vehiclePenetration.js

@@ -0,0 +1,1157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriGrid = exports.PENETRATION_THRESHOLDS = void 0;
+exports.bodyPartOfBone = bodyPartOfBone;
+exports.isAccessoryBone = isAccessoryBone;
+exports.buildSkeleton = buildSkeleton;
+exports.cabinPartOfMesh = cabinPartOfMesh;
+exports.segTri = segTri;
+exports.ownSeatTriangles = ownSeatTriangles;
+exports.vertexSpacing = vertexSpacing;
+exports.projectedArea = projectedArea;
+exports.measurePenetration = measurePenetration;
+exports.evidenceClusters = evidenceClusters;
+exports.evidenceCamera = evidenceCamera;
+exports.clusterRow = clusterRow;
+exports.judgePenetration = judgePenetration;
+exports.PENETRATION_THRESHOLDS = {
+    /** A vertex counts as through a surface beyond this depth (below it is touching). */
+    contactMinM: 0.001,
+    /** A cluster deeper than this... */
+    failDepthM: 0.008,
+    /** ...over at least this much area (of the part deeper than `failDepthM`) fails the seat. 4 cm². */
+    failAreaM2: 4e-4,
+    /** A part sunk deeper than a finger is thick has disappeared, whatever its footprint: deeper than this... */
+    swallowDepthM: 0.025,
+    /** ...over at least this much (fingertips 46 mm into a thigh measured 3.1 cm²) fails too. */
+    swallowAreaM2: 1.5e-4,
+    /** A cluster needs this many vertices (or object samples) past the fail depth: one or two vertices of a sparse
+     *  garment poking through a card (a sleeve corner) is a near-contact, never a fail. */
+    failMinPoints: 3,
+    /** A hand closing on the steering wheel rim, a sole pressing a pedal pad: the part is MEANT to touch, and a grip or a
+     *  press always sinks a few millimetres into the other surface. Those pairings fail only beyond this depth. */
+    contactPairDepthM: 0.02,
+    /** Penetrating vertices closer than this belong to the same cluster. */
+    linkM: 0.03,
+    /** A breached bone's recorded entry point is this far back from its crossing, on the free side. */
+    anchorBackoffM: 0.005,
+};
+// ------------------------------------------------------------------------------------------------------- vector bits
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const crs = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const nrm = (a) => { const l = Math.hypot(a[0], a[1], a[2]) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+const r4 = (v) => Math.round(v * 10000) / 10000;
+const r6 = (v) => Math.round(v * 1e6) / 1e6;
+// ------------------------------------------------------------------------------------------------------- body parts
+const BONE_EXCLUDE = /twist|facial|^ik_|_ik$|^ik$|corrective|helper|socket|attach|weapon|camera|^root$|armature/i;
+const PART_RES = [
+    [/head|neck|jaw|eye|skull/i, 'head'],
+    [/pelvis|hips?$|hip_|^hip/i, 'hip'],
+    [/thumb|index|middle|ring|pinky|pinkie|finger|hand|palm|wrist|carpal/i, 'hand'],
+    [/thigh|upleg|upperleg|upper_leg|femur/i, 'thigh'],
+    [/foot|ball|toe|ankle/i, 'foot'],
+    [/calf|shin|knee|lowerleg|lower_leg|leg|tibia/i, 'leg'],
+    [/clavicle|shoulder|spine|chest|torso|abdomen|belly|breast|neck/i, 'torso'],
+    [/upperarm|lowerarm|forearm|arm|elbow/i, 'arm'],
+];
+function bodyPartOfBone(name) {
+    for (const [re, part] of PART_RES)
+        if (re.test(name))
+            return part;
+    return null;
+}
+/**
+ * Secondary / accessory bones — a tail, a skirt or coat flap, hair, ears, a cape: VRM's `J_Sec_*` / `J_Opt_*`, spring
+ * chains. Their geometry is the AVATAR's (spring-simulated, avatar-specific), not something a vehicle's seat can fit, so
+ * it is not judged; a fox tail through the floor pan is the avatar's business. Bust bones are the torso.
+ */
+const ACCESSORY_RE = /(^|[_.])(sec|opt)([_.]|$)|tail|skirt|hair|ponytail|braid|(^|[_.\s])ears?($|[_.\s\d])|cape|cloak|ribbon|spring|scarf|coat|cloth|dress|wing|horn|antenna|jiggle|physics|dynamic|accessor|strap/i;
+function isAccessoryBone(name) {
+    return !/bust|breast/i.test(name) && ACCESSORY_RE.test(name);
+}
+/** Parts a seat holds up: their contact with the occupant's OWN seat is support, not clipping. */
+const SUPPORTED = new Set(['hip', 'torso', 'thigh', 'arm', 'head']);
+/** Normalising radius per part for the nearest-bone fallback (a finger on a thigh is the finger's, not the thigh's). */
+const PART_RADIUS = { head: 0.1, torso: 0.16, hip: 0.15, arm: 0.05, hand: 0.03, thigh: 0.085, knee: 0.085, leg: 0.06, foot: 0.045 };
+/** UE mannequin parents, for pulls older than `boneParents` (the calibration dumps of 2026-10-02). */
+const UE_PARENTS = (() => {
+    const p = { pelvis: 'root', spine_01: 'pelvis', spine_02: 'spine_01', spine_03: 'spine_02', spine_04: 'spine_03', spine_05: 'spine_04', neck_01: 'spine_05', neck_02: 'neck_01', head: 'neck_02' };
+    for (const s of ['l', 'r']) {
+        Object.assign(p, {
+            [`clavicle_${s}`]: 'spine_05', [`upperarm_${s}`]: `clavicle_${s}`, [`lowerarm_${s}`]: `upperarm_${s}`, [`hand_${s}`]: `lowerarm_${s}`,
+            [`thigh_${s}`]: 'pelvis', [`calf_${s}`]: `thigh_${s}`, [`foot_${s}`]: `calf_${s}`, [`ball_${s}`]: `foot_${s}`,
+            [`upperarm_twist_01_${s}`]: `upperarm_${s}`, [`upperarm_twist_02_${s}`]: `upperarm_${s}`, [`lowerarm_twist_01_${s}`]: `lowerarm_${s}`, [`lowerarm_twist_02_${s}`]: `lowerarm_${s}`,
+            [`thigh_twist_01_${s}`]: `thigh_${s}`, [`calf_twist_01_${s}`]: `calf_${s}`,
+        });
+        for (const f of ['thumb', 'index', 'middle', 'ring', 'pinky']) {
+            p[`${f}_01_${s}`] = `hand_${s}`;
+            p[`${f}_02_${s}`] = `${f}_01_${s}`;
+            p[`${f}_03_${s}`] = `${f}_02_${s}`;
+        }
+    }
+    return p;
+})();
+/** Bone segments from the pelvis outwards (twist/facial/ik helpers skipped), plus a short extension past each head,
+ *  hand and foot leaf so the skull, finger tips and toes have a segment of their own. */
+function buildSkeleton(bones, parentsIn) {
+    const names = Object.keys(bones);
+    // A live pull can report a bone's parent as null (the finger roots: their parent is not a THREE.Bone in some rigs);
+    // fall back to the standard skeleton's parent then, or every finger vertex maps to whatever segment is left.
+    const rawParent = (n) => parentsIn?.[n] ?? UE_PARENTS[n] ?? null;
+    const root = names.find((n) => /^(pelvis|hips)$/i.test(n)) ?? names.find((n) => /pelvis|hips/i.test(n));
+    if (!root)
+        return null;
+    const parent = new Map();
+    for (const n of names) {
+        if (BONE_EXCLUDE.test(n))
+            continue;
+        let p = rawParent(n);
+        while (p && (BONE_EXCLUDE.test(p) || !bones[p]))
+            p = rawParent(p);
+        parent.set(n, p);
+    }
+    // keep only the tree under the root
+    const under = (n) => { for (let p = n, k = 0; p && k < 64; p = parent.get(p) ?? null, k++)
+        if (p === root)
+            return true; return false; };
+    const children = new Map();
+    for (const [n, p] of parent)
+        if (n !== root && p && under(n)) {
+            if (!children.has(p))
+                children.set(p, []);
+            children.get(p).push(n);
+        }
+    const segments = [];
+    // a bone's part: its own name, else (an unrecognised rig name) its nearest recognised ancestor's; accessory chains
+    // stay accessory all the way down
+    const partMemo = new Map();
+    const accMemo = new Map();
+    const isAcc = (n) => {
+        if (accMemo.has(n))
+            return accMemo.get(n);
+        let v = false;
+        for (let b = n, k = 0; b && k < 64 && b !== root; b = parent.get(b) ?? null, k++)
+            if (isAccessoryBone(b)) {
+                v = true;
+                break;
+            }
+        accMemo.set(n, v);
+        return v;
+    };
+    const partOf = (n) => {
+        if (partMemo.has(n))
+            return partMemo.get(n);
+        let v = 'torso';
+        for (let b = n, k = 0; b && k < 64; b = parent.get(b) ?? null, k++) {
+            const q = bodyPartOfBone(b);
+            if (q) {
+                v = q;
+                break;
+            }
+        }
+        partMemo.set(n, v);
+        return v;
+    };
+    for (const [p, cs] of children) {
+        const pp = partOf(p);
+        for (const c of cs) {
+            const cp = partOf(c);
+            // pelvis -> hip joint and pelvis -> spine are the hips; spine -> neck the torso; neck -> head the head
+            const part = pp === 'hip' ? 'hip' : pp === 'torso' && cp === 'head' ? 'torso' : pp;
+            const len = dist(bones[p], bones[c]);
+            const r = part === 'hand' && len < 0.06 ? 0.012 : PART_RADIUS[part];
+            segments.push({ start: p, end: c, a: bones[p], b: bones[c], part, r, ...(isAcc(c) ? { accessory: true } : {}) });
+        }
+    }
+    for (const [n, p] of parent) {
+        if (!p || children.has(n) || !under(n) || isAcc(n))
+            continue;
+        const part = partOf(n);
+        if (part !== 'head' && part !== 'foot' && part !== 'hand')
+            continue;
+        const d = sub(bones[n], bones[p]);
+        const l = Math.hypot(d[0], d[1], d[2]);
+        if (l < 1e-4)
+            continue;
+        const ext = part === 'head' ? 0.16 : part === 'foot' ? 0.07 : /hand|palm|wrist/i.test(n) ? 0.09 : Math.min(0.03, 0.8 * l);
+        const u = nrm(d);
+        segments.push({ start: n, end: null, a: bones[n], b: [bones[n][0] + u[0] * ext, bones[n][1] + u[1] * ext, bones[n][2] + u[2] * ext], part, r: part === 'hand' && ext <= 0.03 ? 0.012 : PART_RADIUS[part] });
+    }
+    return { root, segments, parent, children };
+}
+function closestT(p, a, b) {
+    const ab = sub(b, a);
+    const l2 = dot(ab, ab);
+    return l2 < 1e-12 ? 0 : Math.max(0, Math.min(1, dot(sub(p, a), ab) / l2));
+}
+// ------------------------------------------------------------------------------------------------------- cabin parts
+const NAME_PARTS = [
+    [/parking_?brake|hand_?brake|console|gear|shift|knob|armrest|cup_?holder|tunnel|cent(re|er)_?stack/i, 'console'],
+    [/pedal|throttle|clutch|accelerator/i, 'pedals'],
+    [/steer|wheel_?rim|stalk|column|horn/i, 'wheel'],
+    [/seat|cushion|backrest|headrest|squab|bench|bolster/i, 'seat'],
+    [/roof|headliner|ceiling|lining|sunroof|visor/i, 'roof'],
+    [/door|card/i, 'door'],
+    [/glass|windshield|windscreen|window/i, 'glass'],
+    [/pillar|[abc]_?post|cabinframe|cabin_frame|roll_?cage|cage/i, 'pillar'],
+    [/dash|gauge|cluster|instrument|glove_?box|vent|needle|radio|hvac|speedo|tacho|screen|display|mirror_?interior|rearview/i, 'dash'],
+    [/floor|carpet|mat$|mat_|footwell|underbody|pan$|tub|arch|well|sill|kick/i, 'floor'],
+    [/body|shell|chassis|interior|cabin|^mesh(_?\d+)?$|unnamed|object|default|^node/i, 'generic'],
+];
+/** Cabin part from a mesh name, or `generic` when the name says nothing (a `bodyshell_1` that holds half the cabin). */
+function cabinPartOfMesh(name) {
+    for (const [re, part] of NAME_PARTS)
+        if (re.test(name))
+            return part;
+    return 'other';
+}
+/** A generic-named triangle's part, from where it sits around the occupant (normals are not trusted, only their axis). */
+function cabinPartAt(c, n, f) {
+    const flat = Math.abs(n[1]) > 0.7;
+    if (flat && c[1] > f.headY - 0.08)
+        return 'roof';
+    if (c[1] < f.pelvis[1] - 0.15)
+        return 'floor';
+    if (c[2] > f.pelvis[2] + 0.35 && c[1] < f.headY)
+        return 'dash';
+    if (c[1] > f.headY - 0.15)
+        return 'pillar';
+    const outboard = f.side !== 0 && Math.sign(c[0] - f.pelvis[0]) === f.side;
+    if (outboard && Math.abs(c[0] - f.pelvis[0]) > 0.12)
+        return 'door';
+    if (!outboard && Math.abs(c[0] - f.pelvis[0]) > 0.12 && c[1] < f.pelvis[1] + 0.35)
+        return 'console';
+    return 'other';
+}
+/** Crossings of wall surfaces closer than this along a bone are one wall (the two faces of a slab, a carpet on its pan). */
+const WALL_MERGE_M = 0.03;
+/** Sample spacing over a small cabin object's surface when testing it against the limbs. */
+const OBJECT_SAMPLE_M = 0.005;
+// ------------------------------------------------------------------------------------------------------- triangle grid
+class TriGrid {
+    tris;
+    cell;
+    min;
+    dims;
+    cells = new Map();
+    stamp;
+    tick = 0;
+    constructor(tris, cell = 0.04) {
+        this.tris = tris;
+        this.cell = cell;
+        const n = tris.length / 9;
+        let mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity];
+        for (let i = 0; i < tris.length; i += 3)
+            for (let a = 0; a < 3; a++) {
+                const v = tris[i + a];
+                if (v < mn[a])
+                    mn[a] = v;
+                if (v > mx[a])
+                    mx[a] = v;
+            }
+        if (!n) {
+            mn = [0, 0, 0];
+            mx = [0, 0, 0];
+        }
+        this.min = mn;
+        this.dims = [0, 1, 2].map((a) => Math.max(1, Math.ceil((mx[a] - mn[a]) / cell) + 1));
+        this.stamp = new Uint32Array(n);
+        for (let t = 0; t < n; t++) {
+            const k = t * 9;
+            const lo = [0, 1, 2].map((a) => this.ix(Math.min(tris[k + a], tris[k + 3 + a], tris[k + 6 + a]), a));
+            const hi = [0, 1, 2].map((a) => this.ix(Math.max(tris[k + a], tris[k + 3 + a], tris[k + 6 + a]), a));
+            for (let x = lo[0]; x <= hi[0]; x++)
+                for (let y = lo[1]; y <= hi[1]; y++)
+                    for (let z = lo[2]; z <= hi[2]; z++) {
+                        const key = x + this.dims[0] * (y + this.dims[1] * z);
+                        let c = this.cells.get(key);
+                        if (!c) {
+                            c = [];
+                            this.cells.set(key, c);
+                        }
+                        c.push(t);
+                    }
+        }
+    }
+    ix(v, a) { return Math.max(0, Math.min(this.dims[a] - 1, Math.floor((v - this.min[a]) / this.cell))); }
+    /** Every triangle in a cell overlapping the box, once. */
+    query(lo, hi, out) {
+        out.length = 0;
+        if (++this.tick === 0xffffffff) {
+            this.stamp.fill(0);
+            this.tick = 1;
+        }
+        const a = [0, 1, 2].map((k) => this.ix(lo[k], k)), b = [0, 1, 2].map((k) => this.ix(hi[k], k));
+        for (let x = a[0]; x <= b[0]; x++)
+            for (let y = a[1]; y <= b[1]; y++)
+                for (let z = a[2]; z <= b[2]; z++) {
+                    const c = this.cells.get(x + this.dims[0] * (y + this.dims[1] * z));
+                    if (!c)
+                        continue;
+                    for (const t of c)
+                        if (this.stamp[t] !== this.tick) {
+                            this.stamp[t] = this.tick;
+                            out.push(t);
+                        }
+                }
+        return out;
+    }
+}
+exports.TriGrid = TriGrid;
+/** Segment p->q against one triangle (two-sided). Returns the crossing parameter in (0, 1], or -1. */
+function segTri(tris, t, p, q) {
+    const k = t * 9;
+    const dx = q[0] - p[0], dy = q[1] - p[1], dz = q[2] - p[2];
+    const e1x = tris[k + 3] - tris[k], e1y = tris[k + 4] - tris[k + 1], e1z = tris[k + 5] - tris[k + 2];
+    const e2x = tris[k + 6] - tris[k], e2y = tris[k + 7] - tris[k + 1], e2z = tris[k + 8] - tris[k + 2];
+    const px = dy * e2z - dz * e2y, py = dz * e2x - dx * e2z, pz = dx * e2y - dy * e2x;
+    const det = e1x * px + e1y * py + e1z * pz;
+    if (Math.abs(det) < 1e-14)
+        return -1;
+    const inv = 1 / det;
+    const tx = p[0] - tris[k], ty = p[1] - tris[k + 1], tz = p[2] - tris[k + 2];
+    const u = (tx * px + ty * py + tz * pz) * inv;
+    if (u < 0 || u > 1)
+        return -1;
+    const qx = ty * e1z - tz * e1y, qy = tz * e1x - tx * e1z, qz = tx * e1y - ty * e1x;
+    const v = (dx * qx + dy * qy + dz * qz) * inv;
+    if (v < 0 || u + v > 1)
+        return -1;
+    const s = (e2x * qx + e2y * qy + e2z * qz) * inv;
+    return s > 1e-9 && s <= 1 ? s : -1;
+}
+function triNormal(tris, t) {
+    const k = t * 9;
+    const a = [tris[k], tris[k + 1], tris[k + 2]];
+    return nrm(crs(sub([tris[k + 3], tris[k + 4], tris[k + 5]], a), sub([tris[k + 6], tris[k + 7], tris[k + 8]], a)));
+}
+const triCentroid = (tris, t) => {
+    const k = t * 9;
+    return [(tris[k] + tris[k + 3] + tris[k + 6]) / 3, (tris[k + 1] + tris[k + 4] + tris[k + 7]) / 3, (tris[k + 2] + tris[k + 5] + tris[k + 8]) / 3];
+};
+/** Exact distance from p to triangle t (Ericson, closest point on a triangle). */
+function pointTriDist(tris, t, p) {
+    const k = t * 9;
+    const a = [tris[k], tris[k + 1], tris[k + 2]], b = [tris[k + 3], tris[k + 4], tris[k + 5]], c = [tris[k + 6], tris[k + 7], tris[k + 8]];
+    const ab = sub(b, a), ac = sub(c, a), ap = sub(p, a);
+    const d1 = dot(ab, ap), d2 = dot(ac, ap);
+    if (d1 <= 0 && d2 <= 0)
+        return dist(p, a);
+    const bp = sub(p, b);
+    const d3 = dot(ab, bp), d4 = dot(ac, bp);
+    if (d3 >= 0 && d4 <= d3)
+        return dist(p, b);
+    const vc = d1 * d4 - d3 * d2;
+    if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+        const v = d1 / (d1 - d3);
+        return dist(p, [a[0] + ab[0] * v, a[1] + ab[1] * v, a[2] + ab[2] * v]);
+    }
+    const cp = sub(p, c);
+    const d5 = dot(ab, cp), d6 = dot(ac, cp);
+    if (d6 >= 0 && d5 <= d6)
+        return dist(p, c);
+    const vb = d5 * d2 - d1 * d6;
+    if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+        const w = d2 / (d2 - d6);
+        return dist(p, [a[0] + ac[0] * w, a[1] + ac[1] * w, a[2] + ac[2] * w]);
+    }
+    const va = d3 * d6 - d5 * d4;
+    if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
+        const w = (d4 - d3) / (d4 - d3 + (d5 - d6));
+        return dist(p, [b[0] + (c[0] - b[0]) * w, b[1] + (c[1] - b[1]) * w, b[2] + (c[2] - b[2]) * w]);
+    }
+    const den = 1 / (va + vb + vc);
+    const v = vb * den, w = vc * den;
+    return dist(p, [a[0] + ab[0] * v + ac[0] * w, a[1] + ab[1] * v + ac[1] * w, a[2] + ab[2] * v + ac[2] * w]);
+}
+/** Every triangle the segment p->q crosses (with its parameter), optionally skipping a set. */
+function crossings(grid, p, q, skip, buf) {
+    const lo = [Math.min(p[0], q[0]), Math.min(p[1], q[1]), Math.min(p[2], q[2])];
+    const hi = [Math.max(p[0], q[0]), Math.max(p[1], q[1]), Math.max(p[2], q[2])];
+    const out = [];
+    for (const t of grid.query(lo, hi, buf)) {
+        if (skip && skip[t])
+            continue;
+        const s = segTri(grid.tris, t, p, q);
+        if (s > 0)
+            out.push({ t, s });
+    }
+    return out;
+}
+// ------------------------------------------------------------------------------------------------------- own seat
+/**
+ * The triangles of the occupant's own seat: the first surface straight under the hips and thighs and straight behind the
+ * spine, then (a) every triangle of a seat-NAMED mesh that holds one of them, or (b) for a generic mesh (a seat baked into
+ * `bodyshell_1`), the surface connected to them inside a box around the seat. Floor-level flats are never grown into.
+ */
+function ownSeatTriangles(cabin, bones, pelvis, grid) {
+    const { tris, mesh, names } = cabin;
+    const n = tris.length / 9;
+    const own = new Uint8Array(n);
+    const seeds = new Set();
+    const buf = [];
+    const first = (o, d, reach) => {
+        const q = [o[0] + d[0] * reach, o[1] + d[1] * reach, o[2] + d[2] * reach];
+        let best = -1, bs = Infinity;
+        for (const c of crossings(grid, o, q, null, buf))
+            if (c.s < bs) {
+                bs = c.s;
+                best = c.t;
+            }
+        return best;
+    };
+    const probesDown = [];
+    for (const dx of [-0.1, 0, 0.1])
+        for (const dz of [-0.08, 0, 0.1, 0.2])
+            probesDown.push([pelvis[0] + dx, pelvis[1] + 0.05, pelvis[2] + dz]);
+    for (const s of ['l', 'r']) {
+        const th = bones[`thigh_${s}`], ca = bones[`calf_${s}`];
+        if (th && ca)
+            for (const k of [0.3, 0.55]) {
+                const m = lerp(th, ca, k);
+                probesDown.push([m[0], m[1], m[2]]);
+            }
+    }
+    for (const o of probesDown) {
+        const t = first(o, [0, -1, 0], 0.4);
+        if (t >= 0)
+            seeds.add(t);
+    }
+    const spine = Object.keys(bones).filter((b) => /^spine_0[2-5]$|^spine$|^chest$|spine1|spine2|upperchest/i.test(b)).map((b) => bones[b]);
+    for (const sp of spine)
+        for (const dx of [-0.12, 0, 0.12]) {
+            const t = first([sp[0] + dx, sp[1], sp[2]], [0, 0, -1], 0.4);
+            if (t >= 0)
+                seeds.add(t);
+        }
+    const head = bones.head ?? Object.entries(bones).find(([k]) => /head/i.test(k))?.[1];
+    if (head) {
+        const t = first(head, [0, 0, -1], 0.3);
+        if (t >= 0)
+            seeds.add(t);
+    }
+    if (!seeds.size)
+        return own;
+    const box = { min: [pelvis[0] - 0.36, pelvis[1] - 0.4, pelvis[2] - 0.5], max: [pelvis[0] + 0.36, (head?.[1] ?? pelvis[1] + 0.7) + 0.2, pelvis[2] + 0.6] };
+    const inBox = (t) => { const c = triCentroid(tris, t); return c[0] >= box.min[0] && c[0] <= box.max[0] && c[1] >= box.min[1] && c[1] <= box.max[1] && c[2] >= box.min[2] && c[2] <= box.max[2]; };
+    const floorLevel = (t) => Math.abs(triNormal(tris, t)[1]) > 0.8 && triCentroid(tris, t)[1] < pelvis[1] - 0.2;
+    const seatMeshes = new Set();
+    const genericSeeds = [];
+    for (const t of seeds) {
+        const part = cabinPartOfMesh(names[mesh[t]] ?? '');
+        if (part === 'seat')
+            seatMeshes.add(mesh[t]);
+        else if (part === 'generic' && inBox(t) && !floorLevel(t))
+            genericSeeds.push(t);
+    }
+    for (let t = 0; t < n; t++)
+        if (seatMeshes.has(mesh[t]) && inBox(t))
+            own[t] = 1;
+    if (genericSeeds.length) {
+        // connectivity through shared vertex positions (0.1 mm), within the box, never into floor-level flats
+        const key = (x, y, z) => `${Math.round(x * 1e4)},${Math.round(y * 1e4)},${Math.round(z * 1e4)}`;
+        const byVert = new Map();
+        const vkeys = [];
+        for (let t = 0; t < n; t++) {
+            const ks = [];
+            if (cabinPartOfMesh(names[mesh[t]] ?? '') === 'generic' && inBox(t)) {
+                for (let c = 0; c < 3; c++) {
+                    const k = key(tris[t * 9 + c * 3], tris[t * 9 + c * 3 + 1], tris[t * 9 + c * 3 + 2]);
+                    ks.push(k);
+                    let l = byVert.get(k);
+                    if (!l) {
+                        l = [];
+                        byVert.set(k, l);
+                    }
+                    l.push(t);
+                }
+            }
+            vkeys.push(ks);
+        }
+        const stack = [...genericSeeds];
+        for (const s of stack)
+            own[s] = 1;
+        while (stack.length) {
+            const t = stack.pop();
+            for (const k of vkeys[t])
+                for (const u of byVert.get(k) ?? []) {
+                    if (own[u] || mesh[u] !== mesh[t] || floorLevel(u))
+                        continue;
+                    own[u] = 1;
+                    stack.push(u);
+                }
+        }
+    }
+    return own;
+}
+// ------------------------------------------------------------------------------------------------------- area
+/** The vertex spacing of a set of surface points: the median distance to each point's nearest neighbour (pairs closer
+ *  than 1 mm, a cloth layer lying on the skin, are not neighbours). One point alone stands for a 1 cm patch. */
+function vertexSpacing(points) {
+    if (points.length < 2)
+        return 0.01;
+    const cell = 0.02;
+    const hash = new Map();
+    const key = (p) => `${Math.floor(p[0] / cell)},${Math.floor(p[1] / cell)},${Math.floor(p[2] / cell)}`;
+    points.forEach((p, i) => { const k = key(p); if (!hash.has(k))
+        hash.set(k, []); hash.get(k).push(i); });
+    const nn = [];
+    points.forEach((p, i) => {
+        const c = key(p).split(',').map(Number);
+        let best = Infinity;
+        for (let dx = -1; dx <= 1; dx++)
+            for (let dy = -1; dy <= 1; dy++)
+                for (let dz = -1; dz <= 1; dz++) {
+                    for (const j of hash.get(`${c[0] + dx},${c[1] + dy},${c[2] + dz}`) ?? []) {
+                        if (j === i)
+                            continue;
+                        const d = dist(p, points[j]);
+                        if (d > 0.001 && d < best)
+                            best = d;
+                    }
+                }
+        if (Number.isFinite(best))
+            nn.push(best);
+    });
+    if (!nn.length)
+        return 0.01;
+    nn.sort((x, y) => x - y);
+    return Math.min(0.03, Math.max(0.002, nn[Math.floor(nn.length / 2)]));
+}
+/**
+ * Projected area of surface points onto the plane with normal `normal`: each vertex stands for the `spacing` x `spacing`
+ * patch of surface around it (its share of a mesh sampled at that spacing), rasterised on a fine grid so overlapping
+ * patches (a sleeve over the skin, a curved region folding over itself in projection) count once.
+ */
+function projectedArea(points, normal, spacing = vertexSpacing(points)) {
+    if (!points.length)
+        return 0;
+    const n = nrm(normal);
+    const ref = Math.abs(n[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0];
+    const u = nrm(crs(n, ref)), w = crs(n, u);
+    const minSpacing = Array.isArray(spacing) ? Math.min(...spacing) : spacing;
+    const fine = Math.min(0.0025, Math.max(0.0005, minSpacing / 4));
+    const set = new Set();
+    const K = 1 << 20;
+    for (let pi = 0; pi < points.length; pi++) {
+        const p = points[pi];
+        const half = (Array.isArray(spacing) ? spacing[pi] : spacing) / 2;
+        const pu = dot(p, u), pw = dot(p, w);
+        const i0 = Math.round((pu - half) / fine), i1 = Math.round((pu + half) / fine) - 1;
+        const j0 = Math.round((pw - half) / fine), j1 = Math.round((pw + half) / fine) - 1;
+        for (let i = i0; i <= i1; i++)
+            for (let j = j0; j <= j1; j++)
+                set.add((i + K / 2) * K + (j + K / 2));
+    }
+    return set.size * fine * fine;
+}
+/** Every penetration of one seated occupant into the cabin around it (and of its hands into its own thighs). Pure. */
+function measurePenetration(pull, T = exports.PENETRATION_THRESHOLDS) {
+    const t0 = Date.now();
+    const P = pull.points;
+    const nPts = P.length / 3;
+    const { tris, mesh, names } = pull.cabin;
+    const nTris = tris.length / 9;
+    const empty = { seat: pull.seatKey, vertices: nPts, cabinTriangles: nTris, ownSeat: { triangles: 0, meshes: [] }, breached: [], clusters: [], support: [], assignment: 'nearest-bone', accessoryVertices: 0, ms: 0 };
+    const sk = buildSkeleton(pull.bones, pull.boneParents);
+    if (!sk || !nPts)
+        return { ...empty, ms: Date.now() - t0 };
+    const pelvis = pull.bones[sk.root];
+    const headBone = pull.bones.head ?? Object.entries(pull.bones).find(([k]) => /head/i.test(k) && !/top|end/i.test(k))?.[1] ?? [pelvis[0], pelvis[1] + 0.6, pelvis[2]];
+    const frame = { pelvis, headY: headBone[1] + 0.12, side: Math.abs(pelvis[0]) > 0.05 ? Math.sign(pelvis[0]) : 0 };
+    const grid = new TriGrid(tris);
+    const own = nTris ? ownSeatTriangles(pull.cabin, pull.bones, pelvis, grid) : new Uint8Array(0);
+    const meshPart = names.map((nm) => cabinPartOfMesh(nm));
+    const partOfTri = (t) => {
+        if (own[t])
+            return 'seat';
+        const p = meshPart[mesh[t]];
+        return p === 'generic' ? cabinPartAt(triCentroid(tris, t), triNormal(tris, t), frame) : p;
+    };
+    const buf = [];
+    const near = [];
+    // A small closed OBJECT (a steering rim or hub, a pedal pad, a gear knob) is crossed in AND out: a vertex past it is
+    // not inside it, so its crossings count by parity. Every other surface is a WALL: a vertex past it is through it.
+    const objectMesh = names.map((nm) => { const p = cabinPartOfMesh(nm); return p === 'wheel' || p === 'pedals' || p === 'console'; });
+    const isObject = (t) => !own[t] && objectMesh[mesh[t]];
+    const startState = new Map([[sk.root, { odd: false, entry: null, through: null }]]);
+    const segInfo = new Map();
+    const breached = [];
+    const segsByStart = new Map();
+    for (const s of sk.segments) {
+        if (!segsByStart.has(s.start))
+            segsByStart.set(s.start, []);
+        segsByStart.get(s.start).push(s);
+    }
+    const advance = (st, s, cross, upTo) => {
+        let out = st;
+        const len = Math.max(dist(s.a, s.b), 1e-6);
+        let lastWall = -Infinity;
+        for (const c of cross) {
+            if (c.s >= upTo)
+                break;
+            // the two faces of a panel (a door card modelled as a thin slab, a carpet on its pan) are ONE wall
+            if (!isObject(c.t)) {
+                const at = c.s * len;
+                if (at - lastWall < WALL_MERGE_M) {
+                    lastWall = at;
+                    continue;
+                }
+                lastWall = at;
+            }
+            out = out.odd ? { odd: false, entry: null, through: null }
+                : { odd: true, entry: lerp(s.a, s.b, Math.max(0, c.s - T.anchorBackoffM / len)), through: names[mesh[c.t]] ?? '?' };
+        }
+        return out;
+    };
+    const queue = [sk.root];
+    while (queue.length) {
+        const b = queue.shift();
+        const st = startState.get(b) ?? { odd: false, entry: null, through: null };
+        for (const s of segsByStart.get(b) ?? []) {
+            const cross = (nTris && !s.accessory ? crossings(grid, s.a, s.b, own, buf) : []).sort((x, y) => x.s - y.s);
+            segInfo.set(s, { state: st, cross });
+            if (!s.end)
+                continue;
+            const end = advance(st, s, cross, Infinity);
+            startState.set(s.end, end);
+            if (end.odd && !st.odd)
+                breached.push({ bone: s.end, throughMesh: end.through ?? '?' });
+            queue.push(s.end);
+        }
+    }
+    // ---- vertex -> segment
+    const boneNames = pull.boneNames ?? null;
+    const useSkin = !!(pull.pointBone && boneNames && pull.pointBone.length === nPts);
+    const segOfBone = new Map();
+    for (const s of sk.segments) {
+        if (!segOfBone.has(s.start))
+            segOfBone.set(s.start, []);
+        segOfBone.get(s.start).push(s);
+    }
+    const endSeg = new Map();
+    for (const s of sk.segments)
+        if (s.end)
+            endSeg.set(s.end, s);
+    const mapBone = (name) => {
+        for (let b = name, k = 0; b && k < 32; k++) {
+            const segs = segOfBone.get(b);
+            if (segs)
+                return segs;
+            const e = endSeg.get(b);
+            if (e)
+                return [e];
+            b = sk.parent.get(b) ?? pull.boneParents?.[b] ?? UE_PARENTS[b] ?? null;
+        }
+        return [];
+    };
+    const assign = (p, i) => {
+        let cands = bodySegments;
+        if (useSkin) {
+            const c = mapBone(boneNames[pull.pointBone[i]] ?? '');
+            if (c.length)
+                cands = c;
+        }
+        let best = cands[0], bt = 0, bd = Infinity;
+        for (const s of cands) {
+            const t = closestT(p, s.a, s.b);
+            const d = dist(p, lerp(s.a, s.b, t)) / (useSkin ? 1 : s.r);
+            if (d < bd) {
+                bd = d;
+                best = s;
+                bt = t;
+            }
+        }
+        return { s: best, t: bt };
+    };
+    const bodySegments = sk.segments.filter((s) => !s.accessory);
+    const subPart = (s, t) => (s.part === 'thigh' && t > 0.85 ? 'knee' : s.part === 'leg' && t < 0.12 ? 'knee' : s.part);
+    // ---- every vertex: is a cabin surface between it and the free point of its own bone?
+    const hits = [];
+    let accessoryVertices = 0;
+    const assigned = new Array(nPts);
+    for (let i = 0; i < nPts; i++) {
+        const p = [P[i * 3], P[i * 3 + 1], P[i * 3 + 2]];
+        const { s, t } = assign(p, i);
+        const part = subPart(s, t);
+        assigned[i] = { s, t, part };
+        if (s.accessory) {
+            accessoryVertices++;
+            continue;
+        }
+        if (!nTris)
+            continue;
+        // measured against its own bone. (A bone itself through a surface is the envelope test's case below: anchoring
+        // a limb to the last free point of its chain was measured to misfire wherever a wall has a hole — a window opening
+        // lets the shoulder-to-elbow line miss a door the elbow is through, and the whole hand then reads as behind it.)
+        // a leaf's extension (skull top, finger tip, toe) is a guess along the last bone: it can dip through a floor the toes
+        // rest ON, so a vertex on one is measured against the real joint it starts at
+        const anchor = s.end ? lerp(s.a, s.b, t) : s.a;
+        const supported = SUPPORTED.has(part);
+        const all = crossings(grid, p, anchor, null, buf);
+        if (!all.length)
+            continue;
+        const perObject = new Map();
+        for (const c of all)
+            if (isObject(c.t))
+                perObject.set(mesh[c.t], (perObject.get(mesh[c.t]) ?? 0) + 1);
+        const cs = all.filter((c) => !isObject(c.t) || (perObject.get(mesh[c.t]) % 2) === 1);
+        if (!cs.length)
+            continue;
+        const lineLen = dist(p, anchor);
+        let bestDepth = -1, best = null, bestSupport = null;
+        for (const c of cs) {
+            const n = triNormal(tris, c.t);
+            const k = c.t * 9;
+            // How far behind the surface it crossed: its distance to that surface's plane, but never more than the distance to
+            // the crossing itself, nor more than to the nearest surface of the same mesh (a vertex inside a rim tube, a pedal
+            // box or a hollow door is as deep as its way out; a small tilted triangle's plane would say far more).
+            let d = Math.min(Math.abs(dot(sub(p, [tris[k], tris[k + 1], tris[k + 2]]), n)), c.s * lineLen);
+            if (d > T.contactMinM) {
+                const r = d;
+                const mi = mesh[c.t];
+                for (const u of grid.query([p[0] - r, p[1] - r, p[2] - r], [p[0] + r, p[1] + r, p[2] + r], near)) {
+                    if (mesh[u] !== mi)
+                        continue;
+                    const du = pointTriDist(tris, u, p);
+                    if (du < d)
+                        d = du;
+                }
+            }
+            if (supported && own[c.t]) {
+                if (!bestSupport || d > bestSupport.d)
+                    bestSupport = { d, t: c.t };
+                continue;
+            }
+            if (d > bestDepth) {
+                bestDepth = d;
+                best = c;
+            }
+        }
+        if (best && bestDepth >= T.contactMinM) {
+            let n = triNormal(tris, best.t);
+            if (dot(n, sub(anchor, p)) < 0)
+                n = [-n[0], -n[1], -n[2]];
+            hits.push({ i, p, depth: bestDepth, part, mesh: names[mesh[best.t]] ?? '?', cabinPart: partOfTri(best.t), normal: n, support: false, source: 'skin' });
+        }
+        else if (bestSupport && bestSupport.d >= T.contactMinM) {
+            hits.push({ i, p, depth: bestSupport.d, part, mesh: names[mesh[bestSupport.t]] ?? '?', cabinPart: 'seat', normal: triNormal(tris, bestSupport.t), support: true });
+        }
+    }
+    // ---- each limb's own drawn surface: the outermost vertex per (2 cm station, 15 degree sector) around its bone, so a
+    // point can be tested for being INSIDE the limb without occupant triangles
+    const NA = 24, STATION = 0.02;
+    const limbs = [];
+    const polar = (l, p) => {
+        const d = sub(p, l.s.a);
+        const z = dot(d, l.ax);
+        const radial = [d[0] - l.ax[0] * z, d[1] - l.ax[1] * z, d[2] - l.ax[2] * z];
+        return { z, r: Math.hypot(radial[0], radial[1], radial[2]), ang: Math.atan2(dot(radial, l.e2), dot(radial, l.e1)), dir: nrm(radial) };
+    };
+    const binKey = (z, ang) => (Math.floor(z / STATION) + 512) * NA + (Math.floor(((ang + Math.PI) / (2 * Math.PI)) * NA) % NA);
+    {
+        const bySeg = new Map();
+        for (let i = 0; i < nPts; i++) {
+            const a = assigned[i];
+            if (!bySeg.has(a.s))
+                bySeg.set(a.s, []);
+            bySeg.get(a.s).push(i);
+        }
+        for (const [seg, idx] of bySeg) {
+            if (seg.accessory || !seg.end)
+                continue;
+            const axis = sub(seg.b, seg.a);
+            const L = Math.hypot(axis[0], axis[1], axis[2]);
+            if (L < 0.02 || idx.length < 12)
+                continue;
+            const ax = nrm(axis);
+            const ref = Math.abs(ax[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0];
+            const e1 = nrm(crs(ax, ref)), e2 = crs(ax, e1);
+            const l = { s: seg, ax, e1, e2, L, bins: new Map(), rMax: 0, lo: [Infinity, Infinity, Infinity], hi: [-Infinity, -Infinity, -Infinity] };
+            for (const i of idx) {
+                const p = [P[i * 3], P[i * 3 + 1], P[i * 3 + 2]];
+                const q = polar(l, p);
+                if (q.z < 0 || q.z > L)
+                    continue;
+                const k = binKey(q.z, q.ang);
+                if ((l.bins.get(k) ?? 0) < q.r)
+                    l.bins.set(k, q.r);
+                if (q.r > l.rMax)
+                    l.rMax = q.r;
+                for (let c = 0; c < 3; c++) {
+                    if (p[c] < l.lo[c])
+                        l.lo[c] = p[c];
+                    if (p[c] > l.hi[c])
+                        l.hi[c] = p[c];
+                }
+            }
+            if (l.bins.size >= 6)
+                limbs.push(l);
+        }
+    }
+    /** How deep a point is inside a limb's drawn surface (null: outside, or the limb's surface is not known there). */
+    const insideLimb = (l, p) => {
+        if (p[0] < l.lo[0] || p[1] < l.lo[1] || p[2] < l.lo[2] || p[0] > l.hi[0] || p[1] > l.hi[1] || p[2] > l.hi[2])
+            return null;
+        const q = polar(l, p);
+        if (q.z < 0 || q.z > l.L || q.r > l.rMax)
+            return null;
+        const zi = Math.floor(q.z / STATION), ai = Math.floor(((q.ang + Math.PI) / (2 * Math.PI)) * NA) % NA;
+        let rs = 0, seen = 0;
+        for (const dz of [-1, 0, 1])
+            for (const da of [-1, 0, 1]) {
+                const v = l.bins.get((zi + dz + 512) * NA + ((ai + da + NA) % NA));
+                if (v !== undefined) {
+                    seen++;
+                    rs = Math.max(rs, dz === 0 && da === 0 ? v : v * 0.98);
+                }
+            }
+        // the centre bin itself must be known: a sector with no drawn vertex (the gap between curled fingers) is not flesh
+        if (seen < 4 || !l.bins.has((zi + 512) * NA + ai) || rs <= 0)
+            return null;
+        const depth = rs - q.r;
+        return depth >= T.contactMinM ? { depth, dir: q.dir } : null;
+    };
+    // ---- hands into the occupant's own thighs
+    for (const l of limbs) {
+        if (l.s.part !== 'thigh')
+            continue;
+        for (let i = 0; i < nPts; i++) {
+            if (assigned[i].part !== 'hand')
+                continue;
+            const p = [P[i * 3], P[i * 3 + 1], P[i * 3 + 2]];
+            const q = polar(l, p);
+            if (q.z < 0.1 * l.L || q.z > 0.9 * l.L)
+                continue;
+            const inn = insideLimb(l, p);
+            if (inn)
+                hits.push({ i, p, depth: inn.depth, part: 'hand', mesh: l.s.start, cabinPart: 'self', normal: [-inn.dir[0], -inn.dir[1], -inn.dir[2]], support: false, source: 'skin' });
+        }
+    }
+    // ---- small cabin OBJECTS inside a limb (a steering rim through a knee, a pedal pad inside a sole, a gear knob in a
+    // thigh): their surface, sampled every 5 mm, tested against each limb's drawn surface. The vertex test cannot see an
+    // object that lies between the skin and the bone (crossed in AND out). Walls are not tested this way: a limb's
+    // envelope (outermost vertex per sector) bulges over concave skin, and a seat bolster baked into a generic mesh would
+    // read as clipping. A hand is judged by its vertices only: a fist closes AROUND the rim it grips.
+    if (nTris && limbs.length) {
+        const body = limbs.filter((l) => l.s.part !== 'hand');
+        const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+        for (const l of body)
+            for (let c = 0; c < 3; c++) {
+                lo[c] = Math.min(lo[c], l.lo[c]);
+                hi[c] = Math.max(hi[c], l.hi[c]);
+            }
+        const near = [];
+        // walls only where a limb's BONE goes through them (a floor through the ankle of a foot sunk 11 cm, an elbow out
+        // through a door card): the wall is tested against that limb within its own radius of the crossing
+        const wallAt = new Map();
+        for (const l of body) {
+            const info = segInfo.get(l.s);
+            for (const c of info?.cross ?? []) {
+                if (isObject(c.t))
+                    continue;
+                const x = lerp(l.s.a, l.s.b, c.s);
+                const r = l.rMax;
+                for (const u of grid.query([x[0] - r, x[1] - r, x[2] - r], [x[0] + r, x[1] + r, x[2] + r], buf)) {
+                    if (mesh[u] !== mesh[c.t] || own[u] || isObject(u))
+                        continue;
+                    if (!wallAt.has(u))
+                        wallAt.set(u, []);
+                    wallAt.get(u).push({ x, l });
+                }
+            }
+        }
+        for (const t of grid.query(lo, hi, near)) {
+            const walls = wallAt.get(t);
+            if (!isObject(t) && !walls)
+                continue;
+            const k = t * 9;
+            const A = [tris[k], tris[k + 1], tris[k + 2]], B = [tris[k + 3], tris[k + 4], tris[k + 5]], C = [tris[k + 6], tris[k + 7], tris[k + 8]];
+            const cand = (walls ? [...new Set(walls.map((w) => w.l))] : body).filter((l) => {
+                for (let c = 0; c < 3; c++)
+                    if (Math.max(A[c], B[c], C[c]) < l.lo[c] || Math.min(A[c], B[c], C[c]) > l.hi[c])
+                        return false;
+                return true;
+            });
+            if (!cand.length)
+                continue;
+            const step = OBJECT_SAMPLE_M;
+            const n = Math.min(400, Math.max(1, Math.ceil(Math.max(dist(A, B), dist(B, C), dist(C, A)) / step)));
+            const mname = names[mesh[t]] ?? '?';
+            for (let i = 0; i <= n; i++)
+                for (let j = 0; j <= n - i; j++) {
+                    const u = i / n, v = j / n;
+                    const p = [A[0] + (B[0] - A[0]) * u + (C[0] - A[0]) * v, A[1] + (B[1] - A[1]) * u + (C[1] - A[1]) * v, A[2] + (B[2] - A[2]) * u + (C[2] - A[2]) * v];
+                    let best = null;
+                    for (const l of cand) {
+                        // a wall counts only within the limb's radius of where its bone crosses it
+                        if (walls && !walls.some((w) => w.l === l && dist(w.x, p) <= l.rMax))
+                            continue;
+                        const inn = insideLimb(l, p);
+                        if (inn && (!best || inn.depth > best.depth))
+                            best = { ...inn, l };
+                    }
+                    if (!best)
+                        continue;
+                    const part = subPart(best.l.s, closestT(p, best.l.s.a, best.l.s.b));
+                    hits.push({ i: -1, p, depth: best.depth, part, mesh: mname, cabinPart: partOfTri(t), normal: [-best.dir[0], -best.dir[1], -best.dir[2]], support: false, source: 'object' });
+                }
+        }
+    }
+    // ---- each skin hit's share of surface: its spacing to its nearest neighbour in the WHOLE occupant cloud (a few
+    // penetrating vertices of a sparse shirt are not each other's neighbours), and which of its neighbours are hits too
+    const occHash = new Map();
+    const OC = 0.03;
+    const ocKey = (x, y, z) => ((Math.floor(x / OC) + 512) * 1024 + (Math.floor(y / OC) + 512)) * 1024 + (Math.floor(z / OC) + 512);
+    for (let i = 0; i < nPts; i++) {
+        const k = ocKey(P[i * 3], P[i * 3 + 1], P[i * 3 + 2]);
+        let l = occHash.get(k);
+        if (!l) {
+            l = [];
+            occHash.set(k, l);
+        }
+        l.push(i);
+    }
+    const neighbourhood = (i) => {
+        const p = [P[i * 3], P[i * 3 + 1], P[i * 3 + 2]];
+        const cand = [];
+        for (let dx = -1; dx <= 1; dx++)
+            for (let dy = -1; dy <= 1; dy++)
+                for (let dz = -1; dz <= 1; dz++) {
+                    for (const j of occHash.get(ocKey(p[0] + dx * OC, p[1] + dy * OC, p[2] + dz * OC)) ?? []) {
+                        if (j === i)
+                            continue;
+                        const d = Math.hypot(P[j * 3] - p[0], P[j * 3 + 1] - p[1], P[j * 3 + 2] - p[2]);
+                        if (d > 0.001)
+                            cand.push([j, d]);
+                    }
+                }
+        if (!cand.length)
+            return { spacing: 0.01, near: [] };
+        const nn = cand.reduce((m, c) => Math.min(m, c[1]), Infinity);
+        const spacing = Math.min(0.03, Math.max(0.002, nn));
+        return { spacing, near: cand.filter((c) => c[1] <= 1.6 * spacing).map((c) => c[0]) };
+    };
+    /** Patch side per hit for the area of the part deeper than `D`: a hit whose neighbours are as deep stands for its full
+     *  share of surface; one at the edge of the region (or alone: a single vertex spike) only for the part of it that the
+     *  surface, interpolated to shallower neighbours, keeps deeper than D. */
+    const patchSides = (hs, D) => {
+        const deepIdx = new Set(hs.filter((h) => h.depth >= D && h.i >= 0).map((h) => h.i));
+        return hs.map((h) => {
+            if (h.source === 'object' || h.i < 0)
+                return OBJECT_SAMPLE_M;
+            const nb = neighbourhood(h.i);
+            const frac = nb.near.length ? nb.near.filter((j) => deepIdx.has(j)).length / nb.near.length : 0;
+            return nb.spacing * Math.max(frac, Math.max(0, (h.depth - D) / h.depth));
+        });
+    };
+    // ---- clusters: per penetrated mesh, vertices linked within linkM
+    const groups = new Map();
+    for (const h of hits) {
+        const k = `${h.support ? 'S' : 'P'}|${h.mesh}|${h.cabinPart}`;
+        if (!groups.has(k))
+            groups.set(k, []);
+        groups.get(k).push(h);
+    }
+    const clusters = [];
+    const support = [];
+    for (const [k, hs] of groups) {
+        const isSupport = k.startsWith('S|');
+        const parent = hs.map((_, i) => i);
+        const findp = (x) => { while (parent[x] !== x) {
+            parent[x] = parent[parent[x]];
+            x = parent[x];
+        } return x; };
+        const cellOf = (p) => [Math.floor(p[0] / T.linkM), Math.floor(p[1] / T.linkM), Math.floor(p[2] / T.linkM)];
+        const hash = new Map();
+        hs.forEach((h, i) => { const c = cellOf(h.p).join(','); if (!hash.has(c))
+            hash.set(c, []); hash.get(c).push(i); });
+        hs.forEach((h, i) => {
+            const c = cellOf(h.p);
+            for (let dx = -1; dx <= 1; dx++)
+                for (let dy = -1; dy <= 1; dy++)
+                    for (let dz = -1; dz <= 1; dz++) {
+                        for (const j of hash.get(`${c[0] + dx},${c[1] + dy},${c[2] + dz}`) ?? []) {
+                            if (j <= i || dist(h.p, hs[j].p) > T.linkM)
+                                continue;
+                            const a = findp(i), b = findp(j);
+                            if (a !== b)
+                                parent[a] = b;
+                        }
+                    }
+        });
+        const comps = new Map();
+        hs.forEach((h, i) => { const r = findp(i); if (!comps.has(r))
+            comps.set(r, []); comps.get(r).push(h); });
+        for (const c of comps.values()) {
+            const nsum = [0, 0, 0];
+            for (const h of c) {
+                nsum[0] += h.normal[0];
+                nsum[1] += h.normal[1];
+                nsum[2] += h.normal[2];
+            }
+            const normal = Math.hypot(nsum[0], nsum[1], nsum[2]) > 1e-6 ? nrm(nsum) : c[0].normal;
+            const area = projectedArea(c.map((h) => h.p), normal, patchSides(c, T.contactMinM));
+            const maxD = c.reduce((m, h) => Math.max(m, h.depth), 0);
+            const counts = new Map();
+            for (const h of c)
+                counts.set(h.part, (counts.get(h.part) ?? 0) + 1);
+            const parts = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+            if (isSupport) {
+                support.push({ bodyPart: parts[0][0], cabinMesh: c[0].mesh, maxDepthM: r4(maxD), areaM2: r6(area), vertices: c.length });
+                continue;
+            }
+            const pair = (c[0].cabinPart === 'wheel' && parts[0][0] === 'hand') || (c[0].cabinPart === 'pedals' && parts[0][0] === 'foot');
+            const failDepth = pair ? T.contactPairDepthM : T.failDepthM;
+            const deep = c.filter((h) => h.depth >= failDepth);
+            const areaDeep = projectedArea(deep.map((h) => h.p), normal, patchSides(c, failDepth).filter((_, k) => c[k].depth >= failDepth));
+            const cen = [0, 0, 0];
+            for (const h of c) {
+                cen[0] += h.p[0] / c.length;
+                cen[1] += h.p[1] / c.length;
+                cen[2] += h.p[2] / c.length;
+            }
+            clusters.push({
+                seat: pull.seatKey, bodyPart: parts[0][0], bodyParts: parts, cabinPart: c[0].cabinPart, cabinMesh: c[0].mesh,
+                maxDepthM: r4(maxD), meanDepthM: r4(c.reduce((s, h) => s + h.depth, 0) / c.length), areaM2: r6(area), areaDeepM2: r6(areaDeep), vertices: c.length,
+                centroid: [r4(cen[0]), r4(cen[1]), r4(cen[2])], normal: [r4(normal[0]), r4(normal[1]), r4(normal[2])],
+                radiusM: r4(c.reduce((m, h) => Math.max(m, dist(h.p, cen)), 0)), failDepthM: failDepth,
+                points: c.filter((_, i) => i % Math.max(1, Math.ceil(c.length / 800)) === 0).map((h) => [r4(h.p[0]), r4(h.p[1]), r4(h.p[2])]),
+                verdict: deep.length >= T.failMinPoints && maxD >= failDepth
+                    && (areaDeep >= T.failAreaM2 - 1e-9 || (maxD >= Math.max(failDepth, T.swallowDepthM) && areaDeep >= T.swallowAreaM2 - 1e-9)) ? 'fail' : 'near',
+            });
+        }
+    }
+    clusters.sort((a, b) => (a.verdict === b.verdict ? b.maxDepthM * Math.sqrt(b.areaM2) - a.maxDepthM * Math.sqrt(a.areaM2) : a.verdict === 'fail' ? -1 : 1));
+    support.sort((a, b) => b.maxDepthM - a.maxDepthM);
+    const ownMeshes = new Set();
+    let ownCount = 0;
+    for (let t = 0; t < nTris; t++)
+        if (own[t]) {
+            ownCount++;
+            ownMeshes.add(names[mesh[t]] ?? '?');
+        }
+    return {
+        seat: pull.seatKey, vertices: nPts, cabinTriangles: nTris, ownSeat: { triangles: ownCount, meshes: [...ownMeshes] }, breached,
+        clusters, support, assignment: useSkin ? 'skin-weights' : 'nearest-bone', accessoryVertices, ms: Date.now() - t0,
+    };
+}
+// ------------------------------------------------------------------------------------------------------- verdicts
+const mmS = (m) => `${(m * 1000).toFixed(0)} mm`;
+const cm2 = (a) => `${(a * 1e4).toFixed(1)} cm²`;
+const describe = (c) => `${c.seat}: ${c.bodyPart} through ${c.cabinPart === 'self' ? `its own ${c.cabinMesh.replace(/_/g, ' ')}` : `the ${c.cabinPart} (${c.cabinMesh})`} ${mmS(c.maxDepthM)} deep, ${cm2(c.areaDeepM2)} deeper than ${mmS(c.failDepthM)} (${cm2(c.areaM2)} in all)`;
+/** The failing clusters worth a picture: deduped by (seat, body part, cabin part), worst first (depth x sqrt(area)). */
+function evidenceClusters(clusters, max = 3) {
+    const score = (c) => c.maxDepthM * Math.sqrt(Math.max(c.areaDeepM2, 1e-6));
+    const seen = new Set();
+    const out = [];
+    for (const c of clusters.filter((x) => x.verdict === 'fail').sort((a, b) => score(b) - score(a))) {
+        const k = `${c.seat}|${c.bodyPart}|${c.cabinPart}`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(c);
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}
+/**
+ * A camera that shows a cluster as geometry crossing, for a frame in which only the occupant and the clashing mesh are
+ * drawn: from the far side of the penetrated surface (the cluster normal points into the occupant, so the camera stands
+ * along its opposite, where the body part comes THROUGH the surface towards it), tilted outboard for a floor or a roof (a
+ * camera under the car would be under the ground), and side-on along the thigh for a hand in its own thigh. Never a
+ * clipping near plane: slicing the occupant reads as torn geometry.
+ */
+function evidenceCamera(c, outboard, occupant) {
+    const n = nrm(c.normal);
+    const side = [outboard || 1, 0, 0];
+    const r = Math.max(0.05, Math.min(0.25, c.radiusM));
+    const D = 0.45 + 1.6 * r;
+    let first;
+    if (c.cabinPart === 'self') {
+        const d = dot(side, n);
+        first = nrm([side[0] - n[0] * d, side[1] - n[1] * d + 0.3, side[2] - n[2] * d]);
+    }
+    else {
+        first = [-n[0], -n[1], -n[2]];
+        if (Math.abs(first[1]) > 0.6)
+            first = nrm([first[0] * 0.45 + side[0] * 0.85, first[1] * 0.45, first[2] * 0.45 + 0.1]);
+    }
+    // the occupant's OTHER parts can stand in front of the clash (a forearm over a knee): of a few views around the first,
+    // keep the one whose line of sight passes the fewest occupant vertices before it reaches the cluster
+    const tilt = (v, w, k) => nrm([v[0] + w[0] * k, v[1] + w[1] * k, v[2] + w[2] * k]);
+    const views = [first, tilt(first, side, 0.8), tilt(first, [0, 1, 0], 0.7), tilt(first, [0, -1, 0], 0.5), tilt(first, [0, 0, 1], 0.8), tilt(first, [0, 0, -1], 0.8), side];
+    const occlusion = (v) => {
+        if (!occupant)
+            return 0;
+        let k = 0;
+        const len = D - r - 0.03;
+        for (let i = 0; i < occupant.length; i += 3) {
+            const q = [occupant[i] - c.centroid[0], occupant[i + 1] - c.centroid[1], occupant[i + 2] - c.centroid[2]];
+            const t = dot(q, v);
+            if (t < r + 0.03 || t > len + r)
+                continue;
+            const perp = Math.hypot(q[0] - v[0] * t, q[1] - v[1] * t, q[2] - v[2] * t);
+            if (perp < 0.04 + 0.1 * (t / D))
+                k++;
+        }
+        return k;
+    };
+    let best = views[0], bestK = occlusion(views[0]);
+    for (const v of views.slice(1)) {
+        if (bestK === 0)
+            break;
+        const k = occlusion(v);
+        if (k < bestK * 0.5) {
+            best = v;
+            bestK = k;
+        }
+    }
+    const pos = [c.centroid[0] + best[0] * D, c.centroid[1] + best[1] * D, c.centroid[2] + best[2] * D];
+    const fov = Math.min(60, Math.max(24, (2 * Math.atan((r + 0.1) / D) * 180) / Math.PI));
+    return { pos, target: c.centroid, fov, near: 0.02, occluders: bestK };
+}
+/** One table row per cluster, for facts and the assert's measured block. */
+function clusterRow(c) {
+    return {
+        seat: c.seat, bodyPart: c.bodyPart, cabinPart: c.cabinPart, cabinMesh: c.cabinMesh, maxDepthMm: +(c.maxDepthM * 1000).toFixed(1),
+        areaCm2: +(c.areaM2 * 1e4).toFixed(1), areaDeepCm2: +(c.areaDeepM2 * 1e4).toFixed(1), vertices: c.vertices, centroid: c.centroid, verdict: c.verdict,
+    };
+}
+/** `vehicle.occupants.penetration` (block) and `vehicle.occupants.near_contact` (warn) over every measured seat. */
+function judgePenetration(results, seats, T = exports.PENETRATION_THRESHOLDS) {
+    const got = results.filter((r) => !!r);
+    const missing = seats.filter((s) => !got.some((r) => r.seat === s));
+    const all = got.flatMap((r) => r.clusters);
+    const fails = all.filter((c) => c.verdict === 'fail');
+    const near = all.filter((c) => c.verdict === 'near');
+    const thresholds = { failDepthMm: T.failDepthM * 1000, failAreaCm2: T.failAreaM2 * 1e4, swallowDepthMm: T.swallowDepthM * 1000, swallowAreaCm2: T.swallowAreaM2 * 1e4, failMinPoints: T.failMinPoints, contactPairDepthMm: T.contactPairDepthM * 1000, contactMinMm: T.contactMinM * 1000 };
+    const perSeat = got.map((r) => ({ seat: r.seat, vertices: r.vertices, accessoryVertices: r.accessoryVertices, cabinTriangles: r.cabinTriangles, ownSeat: r.ownSeat, breached: r.breached, assignment: r.assignment, support: r.support.slice(0, 6) }));
+    const measuredOk = got.length > 0 && missing.length === 0 && got.every((r) => r.vertices > 0 && r.cabinTriangles > 0);
+    return [
+        {
+            id: 'vehicle.occupants.penetration',
+            pass: measuredOk && fails.length === 0,
+            severity: 'block',
+            detail: !got.length ? 'no occupant measured'
+                : !measuredOk ? `penetration not measured for ${missing.length ? missing.join(', ') : got.filter((r) => !r.vertices || !r.cabinTriangles).map((r) => r.seat).join(', ')}`
+                    : fails.length ? `occupant through the cabin: ${fails.slice(0, 6).map(describe).join('; ')}${fails.length > 6 ? `; +${fails.length - 6} more` : ''} (fails deeper than ${mmS(T.failDepthM)} over >= ${cm2(T.failAreaM2)}, or deeper than ${mmS(T.swallowDepthM)} over >= ${cm2(T.swallowAreaM2)})`
+                        : `no occupant surface deeper than ${mmS(T.failDepthM)} over ${cm2(T.failAreaM2)} into the cabin in ${got.map((r) => r.seat).join(', ')}${near.length ? ` (${near.length} near-contacts, see vehicle.occupants.near_contact)` : ''}`,
+            measured: { thresholds, clusters: fails.map(clusterRow), seats: perSeat },
+        },
+        {
+            id: 'vehicle.occupants.near_contact',
+            pass: near.length === 0,
+            severity: 'warn',
+            detail: near.length
+                ? `${near.length} contact${near.length > 1 ? 's' : ''} under the fail threshold: ${near.slice(0, 5).map((c) => `${c.seat} ${c.bodyPart} into ${c.cabinPart === 'self' ? c.cabinMesh : `${c.cabinPart} (${c.cabinMesh})`} ${mmS(c.maxDepthM)}, ${cm2(c.areaM2)}`).join('; ')}${near.length > 5 ? `; +${near.length - 5} more` : ''}`
+                : 'no occupant surface touches the cabin deeper than 1 mm',
+            measured: { thresholds, clusters: near.map(clusterRow) },
+        },
+    ];
+}
+//# sourceMappingURL=vehiclePenetration.js.map