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

package/dist/visualQa/worldWalkMath.js

@@ -0,0 +1,873 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORLD_WALK_CATEGORIES = exports.countDegenerate = exports.WORLD_WALK_THRESHOLDS = void 0;
+exports.sanitizeNodeName = sanitizeNodeName;
+exports.readGlb = readGlb;
+exports.glbMeshNames = glbMeshNames;
+exports.glbPrimitiveIndices = glbPrimitiveIndices;
+exports.masterIndexFor = masterIndexFor;
+exports.hiddenTriangles = hiddenTriangles;
+exports.itemTriangles = itemTriangles;
+exports.drawnVertices = drawnVertices;
+exports.chainParity = chainParity;
+exports.enclosure = enclosure;
+exports.outwardEnclosure = outwardEnclosure;
+exports.garmentEdges = garmentEdges;
+exports.restCoverage = restCoverage;
+exports.deepCoveredTriangles = deepCoveredTriangles;
+exports.measurePoke = measurePoke;
+exports.clusterPoke = clusterPoke;
+exports.classifyHoles = classifyHoles;
+exports.components = components;
+exports.holeFrameFails = holeFrameFails;
+exports.judgeHoles = judgeHoles;
+exports.judgePoke = judgePoke;
+exports.worldWalkEnabled = worldWalkEnabled;
+// The measurements of the world-walk stage (`worldWalk.ts`), pure: no browser, no I/O.
+//
+// A garment that passes in the customiser's idle pose can still look broken the moment it is worn and walked: a skirt
+// opens up a see-through hole as the legs move, a foot comes out through a shoe or a gown's hem. Two measured asserts,
+// per base, taken at several poses of a real walk in the test grounds:
+//
+//   wear.walk.no_holes         SEE-THROUGH HOLES. The runtime hides the body a garment covers by collapsing those
+//                              triangles (helix-web-engine-new `regionHide.ts`), so wherever the garment fails to cover a
+//                              hidden region the player sees straight through the body. Measured by drawing the hidden
+//                              triangles again, in flat magenta (pass `p1`, everything else flat), and counting the magenta
+//                              pixels the garment's OUTWARD faces do not cover (pass `p2`, the item alone, front faces
+//                              only, flat green). Hidden body poking out of the garment is invisible in the real render,
+//                              which is why a magenta pixel in front of the garment's own outer surface does not count.
+//   wear.walk.no_poke_through  BODY THROUGH THE GARMENT. A drawn body vertex is through the garment when a garment surface
+//                              lies between it and the bone it hangs off (the segment from the closest point on its own
+//                              bone to the vertex crosses a garment triangle) and no garment surface covers it from
+//                              outside within a cloth's thickness. Only vertices the garment COVERED in the rest pose are
+//                              judged (a surface outside them within reach, none inside), so what the item is built to
+//                              sit inside (an ear's root in the skull, hair roots in the scalp) never counts: this is the
+//                              motion defect the idle pose cannot show. Clustered (3 cm) and judged by depth and area.
+//
+// The thresholds and the fixtures they were calibrated on are in `worldWalkMath.spec.ts`.
+const vehiclePenetration_1 = require("./vehiclePenetration");
+exports.WORLD_WALK_THRESHOLDS = {
+    /** Rest-pose coverage: a garment surface within this distance OUTSIDE a body vertex covers it. */
+    coverReachM: 0.15,
+    /** In motion, a vertex the garment crossed inwards is still covered (not through) when a garment surface lies within
+     *  this distance outside it (a lining crossed, the shell still over it). */
+    outsideReachM: 0.08,
+    /** A vertex through the garment must be out in the open: at most this share of its outward directions meets the
+     *  garment within `pokeEnclosureReachM` (loose trousers' shell sits 8-10 cm off the knee: 0.78; a thigh out through a skirt
+     *  panel: 0.27; a foot out of a gown: 0.20). */
+    pokeEnclosedMax: 0.5,
+    pokeEnclosureReachM: 0.15,
+    /** A vertex counts as through the garment beyond this depth (below it, touching). */
+    contactMinM: 0.002,
+    /** A poke cluster fails with at least `failMinPoints` points deeper than this... */
+    failDepthM: 0.008,
+    /** ...whose part deeper than `failDepthM` covers at least this much (4 cm²). */
+    failAreaM2: 4e-4,
+    failMinPoints: 3,
+    /** Poking vertices closer than this are one cluster. */
+    linkM: 0.03,
+    /** A joint whose chain crossed the garment since the rest pose counts as through it only this far past the crossing. */
+    limbMinM: 0.015,
+    /** A chain crossing this close to the garment's open edge (a hem, a cuff's rim) is a bone grazing the opening: not counted. */
+    limbEdgeM: 0.04,
+    /** Enclosure rays (see `enclosure`) reach this far. */
+    enclosureReachM: 0.3,
+    /** A joint counts as having left the garment only when at most this share of directions still meets it... */
+    limbEnclosedMax: 0.5,
+    /** ...and at least this much less than at rest. */
+    limbEnclosureDrop: 0.25,
+    /** Hands and fingers swing against a garment by design (a hand brushing a skirt): through its surface they fail only
+     *  beyond this depth. */
+    handFailDepthM: 0.02,
+    /** Depth recorded for the vertices of a limb that went through (distance back to the crossing), at most this. */
+    limbDepthCapM: 0.25,
+    /** Holes: covered skin within this distance of skin the garment does not cover at rest is the garment's edge band (a hem
+     *  or a slit may uncover it in a normal stride), so it is not drawn as sentinel. */
+    holeErodeM: 0.05,
+    /** Holes: a connected group of see-through pixels (magenta not under the garment's outer faces) smaller than this
+     *  share of the garment's drawn pixels in the same frame is a seam speck, not a hole... */
+    holeMinBlobFraction: 0.004,
+    /** ...and smaller than this many pixels (at the frame's own resolution) too. */
+    holeMinBlobPx: 120,
+    /** A frame fails when its largest see-through blob is at least BOTH of the above. */
+};
+// ------------------------------------------------------------------------------------------------------- GLB tables
+/** three.js `PropertyBinding.sanitizeNodeName`: the name a GLB node gets as an Object3D. */
+function sanitizeNodeName(name) {
+    return name.replace(/\s/g, '_').replace(/[[\].:/]/g, '');
+}
+/** The JSON and BIN chunks of a GLB, or null when it is not one. */
+function readGlb(glb) {
+    if (glb.length < 20)
+        return null;
+    const dv = new DataView(glb.buffer, glb.byteOffset, glb.byteLength);
+    if (dv.getUint32(0, true) !== 0x46546c67)
+        return null;
+    let off = 12;
+    let json = null;
+    let bin = null;
+    while (off + 8 <= glb.length) {
+        const len = dv.getUint32(off, true);
+        const type = dv.getUint32(off + 4, true);
+        const body = glb.subarray(off + 8, off + 8 + len);
+        if (type === 0x4e4f534a) {
+            try {
+                json = JSON.parse(new TextDecoder().decode(body));
+            }
+            catch {
+                return null;
+            }
+        }
+        else if (type === 0x004e4942)
+            bin = body;
+        off += 8 + len + ((4 - (len % 4)) % 4);
+    }
+    return json ? { json, bin } : null;
+}
+/** The names an item's meshes get in the scene: every mesh node's and mesh's name, sanitised as three.js does. */
+function glbMeshNames(glb) {
+    const g = readGlb(glb);
+    if (!g)
+        return [];
+    const out = new Set();
+    for (const n of g.json.nodes ?? [])
+        if (n.mesh !== undefined && n.name)
+            out.add(sanitizeNodeName(n.name));
+    for (const m of g.json.meshes ?? [])
+        if (m.name)
+            out.add(sanitizeNodeName(m.name));
+    return [...out].filter(Boolean);
+}
+/** Every indexed primitive's index buffer (uncompressed GLBs; a compressed one yields none). */
+function glbPrimitiveIndices(glb) {
+    const g = readGlb(glb);
+    if (!g?.bin)
+        return [];
+    const { json, bin } = g;
+    const out = [];
+    for (const m of json.meshes ?? []) {
+        for (const p of m.primitives ?? []) {
+            if (p.indices === undefined || p.attributes.POSITION === undefined)
+                continue;
+            const acc = json.accessors?.[p.indices];
+            const pos = json.accessors?.[p.attributes.POSITION];
+            if (!acc || !pos || acc.bufferView === undefined)
+                continue;
+            const bv = json.bufferViews?.[acc.bufferView];
+            if (!bv)
+                continue;
+            const start = bin.byteOffset + (bv.byteOffset ?? 0) + (acc.byteOffset ?? 0);
+            const size = acc.componentType === 5125 ? 4 : acc.componentType === 5123 ? 2 : acc.componentType === 5121 ? 1 : 0;
+            if (!size || start - bin.byteOffset + acc.count * size > bin.length)
+                continue;
+            const dv = new DataView(bin.buffer, start, acc.count * size);
+            const idx = new Uint32Array(acc.count);
+            for (let i = 0; i < acc.count; i++)
+                idx[i] = size === 4 ? dv.getUint32(i * 4, true) : size === 2 ? dv.getUint16(i * 2, true) : dv.getUint8(i);
+            out.push({ mesh: m.name ?? '', vertexCount: pos.count, indices: idx });
+        }
+    }
+    return out;
+}
+const degenerate = (ix, t) => ix[t * 3] === ix[t * 3 + 1] && ix[t * 3] === ix[t * 3 + 2];
+/**
+ * The master (unhidden) index of a drawn body mesh: the primitive with the same vertex and index counts whose every
+ * triangle agrees with the drawn index — identical where the drawn triangle is whole, and the same first corner where the
+ * runtime collapsed it (`regionHide.ts` keeps corner 0 and repeats it). Null when no primitive matches exactly.
+ */
+function masterIndexFor(prims, vertexCount, current) {
+    for (const p of prims) {
+        if (p.vertexCount !== vertexCount || p.indices.length !== current.length)
+            continue;
+        let ok = true;
+        for (let t = 0; t < current.length / 3 && ok; t++) {
+            if (degenerate(current, t))
+                ok = current[t * 3] === p.indices[t * 3];
+            else
+                ok = current[t * 3] === p.indices[t * 3] && current[t * 3 + 1] === p.indices[t * 3 + 1] && current[t * 3 + 2] === p.indices[t * 3 + 2];
+        }
+        if (ok)
+            return p.indices;
+    }
+    return null;
+}
+/** Triangles the runtime hid (collapsed in the drawn index, whole in the master): the master's corners, flat. */
+function hiddenTriangles(master, current) {
+    const out = [];
+    for (let t = 0; t < current.length / 3; t++) {
+        if (degenerate(current, t) && !degenerate(master, t))
+            out.push(master[t * 3], master[t * 3 + 1], master[t * 3 + 2]);
+    }
+    return out;
+}
+const countDegenerate = (ix) => { let n = 0; for (let t = 0; t < ix.length / 3; t++)
+    if (degenerate(ix, t))
+        n++; return n; };
+exports.countDegenerate = countDegenerate;
+/** The item's posed triangles, flat (9 numbers per triangle). `index` per item mesh comes from the rest pull. */
+function itemTriangles(item, indexByMesh) {
+    let n = 0;
+    const rows = item.map((m) => ({ m, ix: (m.index ?? indexByMesh?.[m.name] ?? null) }));
+    for (const r of rows)
+        if (r.ix)
+            n += Math.floor(r.ix.length / 3);
+    const out = new Float64Array(n * 9);
+    let k = 0;
+    for (const { m, ix } of rows) {
+        if (!ix)
+            continue;
+        for (let t = 0; t < ix.length / 3; t++) {
+            if (degenerate(ix, t))
+                continue;
+            for (let c = 0; c < 3; c++) {
+                const v = ix[t * 3 + c] * 3;
+                out[k++] = m.pos[v];
+                out[k++] = m.pos[v + 1];
+                out[k++] = m.pos[v + 2];
+            }
+        }
+    }
+    return out.subarray(0, k);
+}
+/** Vertices referenced by a whole (drawn) triangle. */
+function drawnVertices(index, vertexCount) {
+    const out = new Uint8Array(vertexCount);
+    for (let t = 0; t < index.length / 3; t++) {
+        if (degenerate(index, t))
+            continue;
+        out[index[t * 3]] = 1;
+        out[index[t * 3 + 1]] = 1;
+        out[index[t * 3 + 2]] = 1;
+    }
+    return out;
+}
+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 dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+function closestOnSegment(p, a, b) {
+    const ab = sub(b, a);
+    const l2 = dot(ab, ab);
+    const t = l2 < 1e-12 ? 0 : Math.max(0, Math.min(1, dot(sub(p, a), ab) / l2));
+    return [a[0] + ab[0] * t, a[1] + ab[1] * t, a[2] + ab[2] * t];
+}
+/** Per bone, the segments a vertex on it can hang off: the ones it starts AND the one that ends at it (its parent's). At a
+ *  bent joint the skin over it is weighted to the child bone but lies beside the parent's segment: anchoring on the
+ *  child's alone puts the anchor on the joint itself and points the "outward" line along the limb instead of across it. */
+function segmentsByBone(sk) {
+    const out = new Map();
+    const add = (b, s) => { if (!out.has(b))
+        out.set(b, []); out.get(b).push(s); };
+    for (const s of sk.segments)
+        add(s.start, s);
+    for (const s of sk.segments)
+        if (s.end)
+            add(s.end, s);
+    return out;
+}
+/** The point on a vertex's own bone it hangs off: the closest point on the segments of its dominant bone (or of the
+ *  nearest ancestor that has one), its parent's segment included. Null for an accessory (spring) bone or a bone outside the body tree. */
+function anchorOf(v, bone, segs, parents) {
+    let b = bone ?? null;
+    for (let k = 0; b && k < 8; k++) {
+        if ((0, vehiclePenetration_1.isAccessoryBone)(b))
+            return null;
+        const ss = segs.get(b);
+        if (ss?.length) {
+            let best = null;
+            let bd = Infinity;
+            for (const s of ss) {
+                if (s.accessory)
+                    continue;
+                const c = closestOnSegment(v, s.a, s.b);
+                const d = dist(c, v);
+                if (d < bd) {
+                    bd = d;
+                    best = c;
+                }
+            }
+            return best;
+        }
+        b = parents[b] ?? null; // twist / helper bones have no segment of their own: their parent's
+    }
+    return null;
+}
+function anyCrossing(grid, p, q, 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])];
+    for (const t of grid.query(lo, hi, buf))
+        if ((0, vehiclePenetration_1.segTri)(grid.tris, t, p, q) > 0)
+            return true;
+    return false;
+}
+/** The crossing of p->q nearest q (largest parameter), or -1. */
+function lastCrossing(grid, p, q, 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])];
+    let best = -1;
+    for (const t of grid.query(lo, hi, buf)) {
+        const s = (0, vehiclePenetration_1.segTri)(grid.tris, t, p, q);
+        if (s > best)
+            best = s;
+    }
+    return best;
+}
+function prepare(pull) {
+    const skeleton = (0, vehiclePenetration_1.buildSkeleton)(pull.bones, pull.parents);
+    return { skeleton, segs: skeleton ? segmentsByBone(skeleton) : new Map() };
+}
+/** Every crossing parameter of p->q with the garment. */
+function allCrossings(grid, p, q, 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)) {
+        const s = (0, vehiclePenetration_1.segTri)(grid.tris, t, p, q);
+        if (s > 0)
+            out.push(s);
+    }
+    return out;
+}
+/**
+ * How many times the bone chain from the root (pelvis) to each joint crosses the garment, and the last crossing on the
+ * way. A joint whose count changes parity between the rest pose and a walk pose has moved THROUGH the garment (a shin out
+ * through a gown's front panel, a knee through a skirt), however deep — the case a vertex-to-own-bone test cannot see,
+ * because the whole limb is then on the outside. Accessory (spring) chains are not followed.
+ */
+function chainParity(sk, grid, edges = null, edgeM = exports.WORLD_WALK_THRESHOLDS.limbEdgeM) {
+    const out = new Map();
+    out.set(sk.root, { n: 0, via: null });
+    const byStart = new Map();
+    for (const s of sk.segments)
+        if (s.end && !s.accessory) {
+            if (!byStart.has(s.start))
+                byStart.set(s.start, []);
+            byStart.get(s.start).push(s);
+        }
+    const buf = [];
+    const queue = [sk.root];
+    while (queue.length) {
+        const p = queue.shift();
+        const pp = out.get(p);
+        for (const s of byStart.get(p) ?? []) {
+            if (!s.end || out.has(s.end))
+                continue;
+            const at = (t) => [s.a[0] + (s.b[0] - s.a[0]) * t, s.a[1] + (s.b[1] - s.a[1]) * t, s.a[2] + (s.b[2] - s.a[2]) * t];
+            // a crossing next to the garment's own open edge (a cuff's rim, a hem) is a bone grazing an opening, not one
+            // going through a panel: it flips with every millimetre of motion, so it is not counted
+            const xs = allCrossings(grid, s.a, s.b, buf).filter((t) => !edges || !edges.near(at(t), edgeM));
+            const last = xs.length ? Math.max(...xs) : -1;
+            out.set(s.end, { n: pp.n + xs.length, via: last > 0 ? at(last) : pp.via });
+            queue.push(s.end);
+        }
+    }
+    return out;
+}
+const DIRS = (() => {
+    const out = [];
+    for (let x = -1; x <= 1; x++)
+        for (let y = -1; y <= 1; y++)
+            for (let z = -1; z <= 1; z++) {
+                if (!x && !y && !z)
+                    continue;
+                const l = Math.hypot(x, y, z);
+                out.push([x / l, y / l, z / l]);
+            }
+    return out;
+})();
+/** How enclosed a point is by the garment: the share of 26 directions in which a ray of `reach` hits it. A joint inside a
+ *  sleeve or a gown reads high (most directions meet cloth), one out in the open low, whatever the garment's internal
+ *  layers do to a crossing count. */
+function enclosure(p, grid, reach = exports.WORLD_WALK_THRESHOLDS.enclosureReachM) {
+    const buf = [];
+    let hits = 0;
+    for (const d of DIRS)
+        if (anyCrossing(grid, p, [p[0] + d[0] * reach, p[1] + d[1] * reach, p[2] + d[2] * reach], buf))
+            hits++;
+    return hits / DIRS.length;
+}
+/** The share of the directions in the hemisphere around `u` in which a ray of `reach` from p meets the garment: a vertex
+ *  through an inner layer (a lining, a liner under loose trousers) still has the shell around it and reads high; one out
+ *  in the open reads low. */
+function outwardEnclosure(p, u, grid, reach) {
+    const buf = [];
+    let n = 0, hits = 0;
+    for (const d of DIRS) {
+        if (d[0] * u[0] + d[1] * u[1] + d[2] * u[2] < 0.2)
+            continue;
+        n++;
+        if (anyCrossing(grid, p, [p[0] + d[0] * reach, p[1] + d[1] * reach, p[2] + d[2] * reach], buf))
+            hits++;
+    }
+    return n ? hits / n : 0;
+}
+function garmentEdges(item, indexByMesh) {
+    const cell = 0.02;
+    const hash = new Map();
+    let count = 0;
+    for (const m of item) {
+        const ix = (m.index ?? indexByMesh?.[m.name] ?? null);
+        if (!ix)
+            continue;
+        const weld = new Map();
+        const id = (v) => {
+            const k = `${Math.round(m.pos[v * 3] * 1e4)},${Math.round(m.pos[v * 3 + 1] * 1e4)},${Math.round(m.pos[v * 3 + 2] * 1e4)}`;
+            let w = weld.get(k);
+            if (w === undefined) {
+                w = v;
+                weld.set(k, v);
+            }
+            return w;
+        };
+        const uses = new Map();
+        for (let t = 0; t < ix.length / 3; t++) {
+            if (degenerate(ix, t))
+                continue;
+            const c = [id(ix[t * 3]), id(ix[t * 3 + 1]), id(ix[t * 3 + 2])];
+            for (let e = 0; e < 3; e++) {
+                const a = c[e], b = c[(e + 1) % 3];
+                if (a === b)
+                    continue;
+                const k = a < b ? `${a}:${b}` : `${b}:${a}`;
+                const u = uses.get(k);
+                if (u)
+                    u[2]++;
+                else
+                    uses.set(k, [a, b, 1]);
+            }
+        }
+        for (const [a, b, n] of uses.values()) {
+            if (n !== 1)
+                continue;
+            count++;
+            const pa = [m.pos[a * 3], m.pos[a * 3 + 1], m.pos[a * 3 + 2]], pb = [m.pos[b * 3], m.pos[b * 3 + 1], m.pos[b * 3 + 2]];
+            const mid = [(pa[0] + pb[0]) / 2, (pa[1] + pb[1]) / 2, (pa[2] + pb[2]) / 2];
+            for (const p of [pa, pb, mid]) {
+                const k = `${Math.floor(p[0] / cell)},${Math.floor(p[1] / cell)},${Math.floor(p[2] / cell)}`;
+                if (!hash.has(k))
+                    hash.set(k, []);
+                hash.get(k).push(p);
+            }
+        }
+    }
+    return {
+        count,
+        near(p, r) {
+            const span = Math.ceil(r / cell);
+            const cx = Math.floor(p[0] / cell), cy = Math.floor(p[1] / cell), cz = Math.floor(p[2] / cell);
+            for (let dx = -span; dx <= span; dx++)
+                for (let dy = -span; dy <= span; dy++)
+                    for (let dz = -span; dz <= span; dz++) {
+                        for (const q of hash.get(`${cx + dx},${cy + dy},${cz + dz}`) ?? [])
+                            if (dist(p, q) < r)
+                                return true;
+                    }
+            return false;
+        },
+    };
+}
+const HAND_RE = /thumb|index|middle|ring|pinky|pinkie|finger|hand|palm|wrist|carpal/i;
+/** The nearest bone up the raw parent chain that `parity` knows (twist and helper bones are not in the skeleton). */
+function knownBone(bone, parity, parents) {
+    let b = bone ?? null;
+    for (let k = 0; b && k < 8; k++) {
+        if (parity.has(b))
+            return b;
+        b = parents[b] ?? null;
+    }
+    return null;
+}
+/**
+ * Rest-pose coverage: per body mesh, which DRAWN vertices the garment covers — a garment surface within `coverReachM`
+ * outside the vertex (along the line from its bone through it) and none between it and its bone — and the rest parity of
+ * every joint's chain.
+ */
+function restCoverage(pull, T = exports.WORLD_WALK_THRESHOLDS, indexByMesh) {
+    const { skeleton, segs } = prepare(pull);
+    const tris = itemTriangles(pull.item, indexByMesh);
+    const covered = pull.body.map((m) => new Uint8Array(m.pos.length / 3));
+    if (!skeleton || !tris.length)
+        return { covered, coveredCount: 0, judged: 0, skeleton: !!skeleton, parity: {} };
+    const grid = new vehiclePenetration_1.TriGrid(tris, 0.04);
+    const parity = Object.fromEntries([...chainParity(skeleton, grid, garmentEdges(pull.item, indexByMesh), T.limbEdgeM)].map(([k, v]) => [k, v.n % 2]));
+    const enclosed = Object.fromEntries(Object.keys(parity).filter((b) => pull.bones[b]).map((b) => [b, enclosure(pull.bones[b], grid, T.enclosureReachM)]));
+    const buf = [];
+    let coveredCount = 0, judged = 0;
+    pull.body.forEach((m, mi) => {
+        const drawn = drawnVertices(m.index ?? [], m.pos.length / 3);
+        for (let i = 0; i < drawn.length; i++) {
+            if (!drawn[i])
+                continue;
+            const v = [m.pos[i * 3], m.pos[i * 3 + 1], m.pos[i * 3 + 2]];
+            const a = anchorOf(v, m.bone?.[i], segs, pull.parents);
+            if (!a)
+                continue;
+            const d = sub(v, a);
+            const r = Math.hypot(d[0], d[1], d[2]);
+            if (r < 1e-4)
+                continue;
+            judged++;
+            const u = [d[0] / r, d[1] / r, d[2] / r];
+            const q = [v[0] + u[0] * T.coverReachM, v[1] + u[1] * T.coverReachM, v[2] + u[2] * T.coverReachM];
+            if (anyCrossing(grid, v, q, buf) && !anyCrossing(grid, a, v, buf)) {
+                covered[mi][i] = 1;
+                coveredCount++;
+            }
+        }
+    });
+    return { covered, coveredCount, judged, skeleton: true, parity, enclosed };
+}
+/**
+ * The body a garment covers deep inside its coverage, for the hole renders: covered DRAWN vertices (rest pose) with no
+ * uncovered drawn vertex within `erodeM`, and per body mesh the drawn triangles all three of whose corners are such
+ * vertices (`sentinel`) and the rest of its drawn triangles (`rest`). Eroding keeps the band a garment's own edge (a hem, a
+ * slit, a neckline) can uncover in a normal stride out of the count: only skin that a hole IN the garment can expose stays.
+ */
+function deepCoveredTriangles(pull, rest, erodeM = exports.WORLD_WALK_THRESHOLDS.holeErodeM) {
+    const cell = erodeM;
+    const hash = new Map();
+    const key = (p, dx = 0, dy = 0, dz = 0) => `${Math.floor(p[0] / cell) + dx},${Math.floor(p[1] / cell) + dy},${Math.floor(p[2] / cell) + dz}`;
+    const drawnBy = pull.body.map((m) => drawnVertices(m.index ?? [], m.pos.length / 3));
+    pull.body.forEach((m, mi) => {
+        const cov = rest.covered[mi];
+        for (let i = 0; i < drawnBy[mi].length; i++) {
+            if (!drawnBy[mi][i] || cov?.[i])
+                continue;
+            const p = [m.pos[i * 3], m.pos[i * 3 + 1], m.pos[i * 3 + 2]];
+            const k = key(p);
+            if (!hash.has(k))
+                hash.set(k, []);
+            hash.get(k).push(p);
+        }
+    });
+    return pull.body.map((m, mi) => {
+        const cov = rest.covered[mi];
+        const deep = new Uint8Array(m.pos.length / 3);
+        let vertices = 0;
+        if (cov)
+            for (let i = 0; i < deep.length; i++) {
+                if (!cov[i])
+                    continue;
+                const p = [m.pos[i * 3], m.pos[i * 3 + 1], m.pos[i * 3 + 2]];
+                let near = false;
+                for (let dx = -1; dx <= 1 && !near; dx++)
+                    for (let dy = -1; dy <= 1 && !near; dy++)
+                        for (let dz = -1; dz <= 1 && !near; dz++) {
+                            for (const q of hash.get(key(p, dx, dy, dz)) ?? [])
+                                if (dist(p, q) < erodeM) {
+                                    near = true;
+                                    break;
+                                }
+                        }
+                if (!near) {
+                    deep[i] = 1;
+                    vertices++;
+                }
+            }
+        const ix = m.index ?? [];
+        const sentinel = [];
+        const restIx = [];
+        for (let t = 0; t < ix.length / 3; t++) {
+            if (degenerate(ix, t)) {
+                restIx.push(ix[t * 3], ix[t * 3 + 1], ix[t * 3 + 2]);
+                continue;
+            }
+            const a = ix[t * 3], b = ix[t * 3 + 1], c = ix[t * 3 + 2];
+            (deep[a] && deep[b] && deep[c] ? sentinel : restIx).push(a, b, c);
+        }
+        return { sentinel, rest: restIx, vertices };
+    });
+}
+/**
+ * One walk pose: every drawn body vertex now through the garment, clustered. Two ways through: (1) a vertex the garment
+ * covered at rest with a garment surface between it and its bone and none over it within a cloth's thickness; (2) any
+ * drawn vertex of a bone whose root-to-joint chain changed crossing parity since the rest pose by more than
+ * `limbMinM` (the bone itself went through), its depth the distance back to that crossing.
+ */
+function measurePoke(sample, pull, rest, T = exports.WORLD_WALK_THRESHOLDS, indexByMesh) {
+    const { skeleton, segs } = prepare(pull);
+    const tris = itemTriangles(pull.item, indexByMesh);
+    if (!skeleton || !tris.length)
+        return { sample, judged: 0, poking: 0, limbsThrough: [], clusters: [] };
+    const grid = new vehiclePenetration_1.TriGrid(tris, 0.04);
+    const parity = chainParity(skeleton, grid, garmentEdges(pull.item, indexByMesh), T.limbEdgeM);
+    const through = new Set();
+    for (const [bone, v] of parity) {
+        if (HAND_RE.test(bone))
+            continue; // a hand swinging into a skirt is the arm's swing, judged as a surface contact only
+        const r0 = rest.parity[bone];
+        if (r0 === undefined || v.n % 2 === r0 || !v.via)
+            continue;
+        if (dist(pull.bones[bone], v.via) < T.limbMinM)
+            continue;
+        // and the joint really left the garment: it was enclosed at rest and is out in the open now (a parity flip alone can
+        // be a bone line crossing an inner layer, a pocket or a fold)
+        const e0 = rest.enclosed?.[bone];
+        const e1 = enclosure(pull.bones[bone], grid, T.enclosureReachM);
+        if (e0 !== undefined && (e1 > T.limbEnclosedMax || e0 - e1 < T.limbEnclosureDrop))
+            continue;
+        through.add(bone);
+    }
+    const buf = [];
+    const pts = [];
+    let judged = 0;
+    pull.body.forEach((m, mi) => {
+        const cov = rest.covered[mi];
+        const drawn = drawnVertices(m.index ?? [], m.pos.length / 3);
+        for (let i = 0; i < drawn.length; i++) {
+            if (!drawn[i])
+                continue;
+            const v = [m.pos[i * 3], m.pos[i * 3 + 1], m.pos[i * 3 + 2]];
+            const bone = m.bone?.[i] ?? null;
+            const kb = knownBone(bone, parity, pull.parents);
+            if (kb && through.has(kb)) {
+                const via = parity.get(kb).via;
+                const a = anchorOf(v, bone, segs, pull.parents) ?? pull.bones[kb];
+                const d = sub(v, a);
+                const r = Math.hypot(d[0], d[1], d[2]) || 1;
+                const u = [d[0] / r, d[1] / r, d[2] / r];
+                // only what is out in the open: a vertex the garment still covers from outside (a toe inside a shoe whose insole
+                // runs along the foot bone) is not through, whatever the bone line did
+                const q = [v[0] + u[0] * T.outsideReachM, v[1] + u[1] * T.outsideReachM, v[2] + u[2] * T.outsideReachM];
+                if (!anyCrossing(grid, v, q, buf) && outwardEnclosure(v, u, grid, T.pokeEnclosureReachM) <= T.pokeEnclosedMax) {
+                    pts.push({ mesh: m.name, vertex: i, p: v, depth: Math.min(dist(v, via), T.limbDepthCapM), bone: bone ?? kb, u, kind: 'limb' });
+                    continue;
+                }
+            }
+            if (!cov?.[i])
+                continue;
+            const a = anchorOf(v, bone, segs, pull.parents);
+            if (!a)
+                continue;
+            judged++;
+            const d = sub(v, a);
+            const r = Math.hypot(d[0], d[1], d[2]);
+            if (r < 1e-4)
+                continue;
+            const s = lastCrossing(grid, a, v, buf);
+            if (s <= 0)
+                continue;
+            const depth = r * (1 - s);
+            if (depth < T.contactMinM)
+                continue;
+            const u = [d[0] / r, d[1] / r, d[2] / r];
+            const q = [v[0] + u[0] * T.outsideReachM, v[1] + u[1] * T.outsideReachM, v[2] + u[2] * T.outsideReachM];
+            if (anyCrossing(grid, v, q, buf))
+                continue; // a lining crossed, the shell still over it
+            if (outwardEnclosure(v, u, grid, T.pokeEnclosureReachM) > T.pokeEnclosedMax)
+                continue; // the shell around it, if not straight over it
+            pts.push({ mesh: m.name, vertex: i, p: v, depth, bone: bone ?? '?', u, kind: 'surface' });
+        }
+    });
+    return { sample, judged, poking: pts.length, limbsThrough: [...through].sort(), clusters: clusterPoke(sample, pts, T) };
+}
+function clusterPoke(sample, pts, T = exports.WORLD_WALK_THRESHOLDS) {
+    const n = pts.length;
+    const seen = new Uint8Array(n);
+    const cell = T.linkM;
+    const hash = new Map();
+    const key = (p, dx = 0, dy = 0, dz = 0) => `${Math.floor(p[0] / cell) + dx},${Math.floor(p[1] / cell) + dy},${Math.floor(p[2] / cell) + dz}`;
+    pts.forEach((p, i) => { const k = key(p.p); if (!hash.has(k))
+        hash.set(k, []); hash.get(k).push(i); });
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        if (seen[i])
+            continue;
+        const members = [];
+        const stack = [i];
+        seen[i] = 1;
+        while (stack.length) {
+            const j = stack.pop();
+            members.push(j);
+            for (let dx = -1; dx <= 1; dx++)
+                for (let dy = -1; dy <= 1; dy++)
+                    for (let dz = -1; dz <= 1; dz++) {
+                        for (const k of hash.get(key(pts[j].p, dx, dy, dz)) ?? []) {
+                            if (seen[k] || dist(pts[j].p, pts[k].p) > T.linkM)
+                                continue;
+                            seen[k] = 1;
+                            stack.push(k);
+                        }
+                    }
+        }
+        const ps = members.map((m) => pts[m]);
+        const deep = ps.filter((p) => p.depth >= (HAND_RE.test(p.bone) ? T.handFailDepthM : T.failDepthM));
+        const mean = [0, 0, 0];
+        for (const p of ps) {
+            mean[0] += p.u[0];
+            mean[1] += p.u[1];
+            mean[2] += p.u[2];
+        }
+        const bones = new Map();
+        for (const p of ps)
+            bones.set(p.bone, (bones.get(p.bone) ?? 0) + 1);
+        const ranked = [...bones.entries()].sort((a, b) => b[1] - a[1]);
+        const areaM2 = (0, vehiclePenetration_1.projectedArea)(ps.map((p) => p.p), mean);
+        const areaDeepM2 = deep.length ? (0, vehiclePenetration_1.projectedArea)(deep.map((p) => p.p), mean) : 0;
+        const c = [0, 0, 0];
+        for (const p of ps) {
+            c[0] += p.p[0] / ps.length;
+            c[1] += p.p[1] / ps.length;
+            c[2] += p.p[2] / ps.length;
+        }
+        const kinds = new Set(ps.map((p) => p.kind));
+        out.push({
+            sample, bone: ranked[0][0], bones: ranked, kind: kinds.size > 1 ? 'mixed' : ps[0].kind, points: ps.length, deepPoints: deep.length,
+            maxDepthM: r5(Math.max(...ps.map((p) => p.depth))), areaM2: r7(areaM2), areaDeepM2: r7(areaDeepM2), centroid: c.map(r4),
+            normal: ((l) => mean.map((x) => r4(x / l)))(Math.hypot(mean[0], mean[1], mean[2]) || 1),
+            verdict: deep.length >= T.failMinPoints && areaDeepM2 >= T.failAreaM2 ? 'fail' : 'near',
+        });
+    }
+    return out.sort((a, b) => b.areaDeepM2 - a.areaDeepM2 || b.maxDepthM - a.maxDepthM);
+}
+const r4 = (v) => Math.round(v * 1e4) / 1e4;
+const r5 = (v) => Math.round(v * 1e5) / 1e5;
+const r7 = (v) => Math.round(v * 1e7) / 1e7;
+const isMagenta = (r, g, b) => r > 150 && b > 150 && g < 110 && Math.abs(r - b) < 100;
+const isGreen = (r, g, b) => g > 150 && r < 110 && b < 110;
+/** Classify one pose/camera: P1 (hidden body magenta, item green) against P2 (item's outer faces green), RGB(A) bytes. */
+function classifyHoles(frame, p1, p2, width, height, channels = 3) {
+    const n = width * height;
+    const hole = new Uint8Array(n);
+    let itemPx = 0, sentinelPx = 0, holePx = 0;
+    for (let i = 0; i < n; i++) {
+        const k = i * channels;
+        const r = p1[k], g = p1[k + 1], b = p1[k + 2];
+        if (isGreen(r, g, b))
+            itemPx++;
+        else if (isMagenta(r, g, b)) {
+            sentinelPx++;
+            if (!isGreen(p2[k], p2[k + 1], p2[k + 2])) {
+                hole[i] = 1;
+                holePx++;
+            }
+        }
+    }
+    const blobs = components(hole, width, height);
+    const big = blobs.sort((a, b) => b.px - a.px)[0] ?? null;
+    return {
+        frame, width, height, itemPx, sentinelPx, holePx,
+        largestBlobPx: big?.px ?? 0,
+        largestBlobFraction: itemPx ? r5((big?.px ?? 0) / itemPx) : 0,
+        blobs: blobs.length,
+        largestBlobBox: big ? big.box : null,
+    };
+}
+/** 8-connected components of a mask: pixel count and bounding box each. */
+function components(mask, width, height) {
+    const seen = new Uint8Array(mask.length);
+    const out = [];
+    const stack = [];
+    for (let s = 0; s < mask.length; s++) {
+        if (!mask[s] || seen[s])
+            continue;
+        let px = 0, x0 = width, y0 = height, x1 = 0, y1 = 0;
+        stack.push(s);
+        seen[s] = 1;
+        while (stack.length) {
+            const i = stack.pop();
+            px++;
+            const x = i % width, y = (i - x) / width;
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+            for (let dy = -1; dy <= 1; dy++)
+                for (let dx = -1; dx <= 1; dx++) {
+                    const nx = x + dx, ny = y + dy;
+                    if (nx < 0 || ny < 0 || nx >= width || ny >= height)
+                        continue;
+                    const j = ny * width + nx;
+                    if (mask[j] && !seen[j]) {
+                        seen[j] = 1;
+                        stack.push(j);
+                    }
+                }
+        }
+        out.push({ px, box: [x0, y0, x1 - x0 + 1, y1 - y0 + 1] });
+    }
+    return out;
+}
+function holeFrameFails(f, T = exports.WORLD_WALK_THRESHOLDS) {
+    return f.largestBlobPx >= T.holeMinBlobPx && f.largestBlobFraction >= T.holeMinBlobFraction;
+}
+/** `wear.walk.no_holes` over every pose/camera of one base. `hidden.triangles` = triangles the runtime hid on that base,
+ *  `hidden.covered` = drawn triangles deep inside the garment's rest coverage (both drawn as sentinel). */
+function judgeHoles(frames, hidden, T = exports.WORLD_WALK_THRESHOLDS) {
+    const thresholds = { holeMinBlobPx: T.holeMinBlobPx, holeMinBlobFraction: T.holeMinBlobFraction };
+    if (!hidden.measurable)
+        return { pass: false, detail: `not measured: ${hidden.why ?? 'the hidden body could not be reconstructed'}`, measured: { hiddenTriangles: hidden.triangles, thresholds } };
+    const coveredTriangles = hidden.covered ?? 0;
+    // Nothing hidden and nothing covered: the hole pass is not run at all (there is nothing to see through), so this is a
+    // genuine pass — the item's own presence was already verified when it was classified and pulled.
+    if (hidden.triangles + coveredTriangles === 0) {
+        return { pass: true, detail: 'the item neither hides nor covers any part of the body on this base, so nothing can be seen through it', measured: { hiddenTriangles: 0, frames: frames.length, thresholds } };
+    }
+    if (!frames.length)
+        return { pass: false, detail: 'not measured: no walk pose was rendered', measured: { hiddenTriangles: hidden.triangles, thresholds } };
+    // The hole pass must have actually drawn the item: a run whose every pose view carries 0 item pixels measured nothing
+    // (the item never rendered in the walk pass), and "nothing to see" is exactly the false pass this assert exists to
+    // remove — fail closed so the run re-renders. (Owner acceptance round 1: a run with hiddenTriangles 0,
+    // coveredTriangles 54 and 0 item pixels in all 16 views passed no_holes; the identical version re-rendered drew
+    // 30k-60k item pixels per view and failed at 13.34 %.)
+    if (!frames.some((f) => f.itemPx > 0)) {
+        return { pass: false, detail: `not measured: the item was never drawn in the walk pass (0 item pixels in all ${frames.length} pose views) — re-render`, measured: { hiddenTriangles: hidden.triangles, coveredTriangles, frames: frames.length, thresholds } };
+    }
+    const failing = frames.filter((f) => holeFrameFails(f, T));
+    const worst = [...frames].sort((a, b) => b.largestBlobFraction - a.largestBlobFraction || b.largestBlobPx - a.largestBlobPx)[0];
+    const rows = frames.map((f) => ({ frame: f.frame, itemPx: f.itemPx, holePx: f.holePx, largestBlobPx: f.largestBlobPx, largestBlobFraction: f.largestBlobFraction }));
+    const measured = { hiddenTriangles: hidden.triangles, coveredTriangles, frames: frames.length, failingFrames: failing.map((f) => f.frame), worst: worst ? { frame: worst.frame, largestBlobPx: worst.largestBlobPx, largestBlobFraction: worst.largestBlobFraction, box: worst.largestBlobBox } : null, rows, thresholds };
+    const pct = (x) => `${(x * 100).toFixed(2)} %`;
+    if (failing.length) {
+        const w = [...failing].sort((a, b) => b.largestBlobFraction - a.largestBlobFraction)[0];
+        return { pass: false, detail: `see-through hole while walking: in ${failing.length} of ${frames.length} pose views the body it hides or covers shows through the item (worst ${w.frame}: ${w.largestBlobPx} px, ${pct(w.largestBlobFraction)} of the item's pixels; limit ${T.holeMinBlobPx} px and ${pct(T.holeMinBlobFraction)})`, measured };
+    }
+    return { pass: true, detail: `no see-through hole in ${frames.length} pose views while walking (largest ${worst?.largestBlobPx ?? 0} px, ${pct(worst?.largestBlobFraction ?? 0)} of the item's pixels; limit ${T.holeMinBlobPx} px and ${pct(T.holeMinBlobFraction)})`, measured };
+}
+/** `wear.walk.no_poke_through` over every walk pose of one base. */
+function judgePoke(samples, cover, T = exports.WORLD_WALK_THRESHOLDS) {
+    const thresholds = { failDepthM: T.failDepthM, failAreaM2: T.failAreaM2, failMinPoints: T.failMinPoints, contactMinM: T.contactMinM, coverReachM: T.coverReachM, outsideReachM: T.outsideReachM, limbMinM: T.limbMinM };
+    if (!cover.skeleton)
+        return { pass: false, detail: 'not measured: the base has no skeleton to measure the body against', measured: { thresholds } };
+    if (!samples.length)
+        return { pass: false, detail: 'not measured: no walk pose was pulled', measured: { thresholds } };
+    // Same fail-closed rule as no_holes: with no drawn item triangles to measure against, "no poke-through" is vacuous.
+    if ((cover.itemTriangles ?? 1) === 0)
+        return { pass: false, detail: 'not measured: the item has no drawn triangles to measure poke-through against', measured: { thresholds } };
+    const clusters = samples.flatMap((s) => s.clusters);
+    const fails = clusters.filter((c) => c.verdict === 'fail');
+    const top = (fails.length ? fails : clusters).slice(0, 8).map((c) => ({ sample: c.sample, bone: c.bone, kind: c.kind, points: c.points, deepPoints: c.deepPoints, maxDepthMm: +(c.maxDepthM * 1000).toFixed(1), areaDeepCm2: +(c.areaDeepM2 * 1e4).toFixed(2), areaCm2: +(c.areaM2 * 1e4).toFixed(2), verdict: c.verdict }));
+    const measured = {
+        coveredVertices: cover.covered, judgedVertices: cover.judged,
+        samples: samples.map((s) => ({ sample: s.sample, judged: s.judged, poking: s.poking, limbsThrough: s.limbsThrough, clusters: s.clusters.length, failing: s.clusters.filter((c) => c.verdict === 'fail').length })),
+        clusters: top, thresholds,
+    };
+    const mm = (m) => (m * 1000).toFixed(0);
+    const cm2 = (a) => (a * 1e4).toFixed(1);
+    if (fails.length) {
+        const w = fails[0];
+        const poses = new Set(fails.map((c) => c.sample)).size;
+        const how = w.kind === 'surface' ? 'through the item\'s surface' : 'with the limb itself outside the item';
+        return { pass: false, detail: `body pokes through the item while walking: ${fails.length} cluster(s) in ${poses} of ${samples.length} poses (worst at ${w.bone}, ${w.sample}, ${how}: ${mm(w.maxDepthM)} mm deep over ${cm2(w.areaDeepM2)} cm²; limit ${mm(T.failDepthM)} mm over ${cm2(T.failAreaM2)} cm²)`, measured };
+    }
+    const worst = clusters[0];
+    return { pass: true, detail: `no body poke-through in ${samples.length} walk poses${worst ? ` (deepest contact ${mm(worst.maxDepthM)} mm over ${cm2(worst.areaDeepM2)} cm² at ${worst.bone})` : ''}; limit ${mm(T.failDepthM)} mm over ${cm2(T.failAreaM2)} cm²`, measured };
+}
+// ------------------------------------------------------------------------------------------------------- options
+exports.WORLD_WALK_CATEGORIES = new Set(['wearable', 'character-addon', 'avatar']);
+/** Whether the world-walk stage runs: on for wearables, character add-ons and avatars unless `--no-world-walk` or
+ *  `HELIX_VQA_WORLD_WALK=0|off|false`. Anything else in the variable is ignored (on). */
+function worldWalkEnabled(category, flag, env = process.env) {
+    if (!exports.WORLD_WALK_CATEGORIES.has(category))
+        return { enabled: false, reason: `a ${category} is not worn` };
+    if (flag === false)
+        return { enabled: false, reason: 'disabled with --no-world-walk' };
+    const v = (env.HELIX_VQA_WORLD_WALK ?? '').trim().toLowerCase();
+    if (v === '0' || v === 'off' || v === 'false' || v === 'no')
+        return { enabled: false, reason: 'disabled with HELIX_VQA_WORLD_WALK' };
+    return { enabled: true, reason: 'on' };
+}
+//# sourceMappingURL=worldWalkMath.js.map