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

package/dist/visualQa/avatarPreviewMath.js

@@ -0,0 +1,696 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointGrid = exports.STANDARD_BIND_DIRECTIONS = exports.BASE_FEMALE_POSTURE = exports.AVATAR_PREVIEW_THRESHOLDS = void 0;
+exports.weightOn = weightOn;
+exports.dominantBone = dominantBone;
+exports.vertexAreas = vertexAreas;
+exports.vertexNormals = vertexNormals;
+exports.weld = weld;
+exports.measureArmsClear = measureArmsClear;
+exports.measureSurfaceClosed = measureSurfaceClosed;
+exports.headHungBones = headHungBones;
+exports.measureSilhouette = measureSilhouette;
+exports.measureStrands = measureStrands;
+exports.measureBindPose = measureBindPose;
+exports.measurePosture = measurePosture;
+exports.judgeArmsClear = judgeArmsClear;
+exports.judgeSurfaceClosed = judgeSurfaceClosed;
+exports.judgeSilhouette = judgeSilhouette;
+exports.judgeStrands = judgeStrands;
+exports.judgeBindPose = judgeBindPose;
+exports.judgePosture = judgePosture;
+exports.backswingPhases = backswingPhases;
+exports.posedBounds = posedBounds;
+exports.AVATAR_PREVIEW_THRESHOLDS = {
+    /** Forearm + hand surface (>= 0.6 weight on lowerarm/hand/fingers) lying more than `armDepthM` behind the nearest
+     *  torso/hip surface (>= 0.6 on pelvis/spine/thigh, within `armNearM`), as an area share AVERAGED over the walk cycle
+     *  (a hand brushing the hip at one phase is fine; arms that walk inside the body are inside most of the cycle).
+     *  Measured on the production page: good Base Male/Female 0, worst Pastel Cyberpunk 0.085 (arms bound at 20 deg,
+     *  pressed to the hips; peak 0.218), Brass 0.059; Cream Hoodie 1.0.6 0.180 (peak 0.259), Base Male arms-low fixture
+     *  0.240, Cream Hoodie 1.0.8 0.000. */
+    armDepthM: 0.03,
+    armNearM: 0.1,
+    armInsideShareMax: 0.13,
+    /** Two sides of a hole: boundary vertices of the same connected surface, within 2 cm of each other at rest but at
+     *  least 7 edges apart along the surface. How far they separate in the walk (cm). Good max 0.8 (Iron Man);
+     *  Cream Hoodie 1.0.6 20.1 (the cut sleeve-to-torso bridge opening as the arm swings back). */
+    holePairRestM: 0.02,
+    holeMinHops: 7,
+    holeOpenMaxM: 0.05,
+    /** Geometry that is neither torso nor limb, between spine_01 and neck_01 height, standing behind / beside the torso's
+     *  own outline (cm, scaled to a 1.70 m body), in two classes: hung from the head (hair, ears) and everything else on
+     *  its own bones (capes, coat tails, accessories). Measured on the production page (held poses, dynamics settled):
+     *  good max Kemonomimi 28.1 (hair) / 21.8 (cape); Cream Hoodie 1.0.6 22.3 (its back hair rides on spine bones, so it
+     *  reads as the second class) — inside the good envelope, so 1.0.6's slab is the vision critic's to judge on the
+     *  motion.preview side frames; this catches gross outliers (the slab fixture: a plate 45 cm off the back). */
+    silhouetteHairMaxM: 0.35,
+    silhouetteClothMaxM: 0.35,
+    /** A detached rest-mesh fragment longer than this, thin (area / extent^2 below `strandThinness`) and small (< 2 % of
+     *  the surface), is a stray strand. None in the good set. A triangle the walk stretches into a sliver (longest edge
+     *  > 4 cm and > 3x its rest length, < 4 mm tall) is recorded as evidence, not judged (good avatars reach 3). */
+    strandMinExtentM: 0.05,
+    strandThinness: 0.02,
+    strandMaxShare: 0.02,
+    /** ... and no vertex of it within this distance of any other surface (it floats). */
+    strandFloatM: 0.02,
+    /** Upper arm bound at least this far from straight down (deg). Base Female 36, worst good Pastel 19.6, Kemonomimi
+     *  (T-pose) 90; Cream Hoodie 1.0.6 13-15: the walk adducts ~24 deg from the clip's A-pose, so an arm bound that
+     *  close walks inside the body. */
+    upperarmAbductionMinDeg: 17,
+    /** Any other canonical bone's bind direction vs Base Female (deg). Good max: lowerarm 60 (T-pose), thigh/calf 36
+     *  (Brass), foot 38 (Cream Hoodie), neck 14 (T-800). */
+    bindDeltaMaxDeg: { spine: 30, neck: 35, clavicle: 35, upperarm: 75, lowerarm: 80, hand: 80, thigh: 50, calf: 50, foot: 60 },
+    /** Neck lean (neck_01 -> head from vertical, sagittal, deg) and torso lean (pelvis -> spine_03) through the walk vs
+     *  Base Female (neck 18.9..23.1, torso 5.2..9.6). Good range: neck 6.8 (Ninja) .. 34.8 (T-800). */
+    neckLeanDeltaMaxDeg: 25,
+    torsoLeanDeltaMaxDeg: 15,
+};
+const T = exports.AVATAR_PREVIEW_THRESHOLDS;
+exports.BASE_FEMALE_POSTURE = { neckLeanDeg: [18.9, 23.1], torsoLeanDeg: [5.2, 9.6] };
+/** Base Female 1.3.1 bind directions (unit, model frame) of the canonical bone pairs. */
+exports.STANDARD_BIND_DIRECTIONS = {
+    'pelvis>spine_01': [0, 0.9982, -0.0602], 'spine_01>spine_03': [0, 0.9871, 0.1602], 'spine_03>neck_01': [0, 0.9897, -0.143], 'neck_01>head': [0, 0.9899, 0.1418],
+    'clavicle_l>upperarm_l': [0.9957, -0.0845, -0.0386], 'upperarm_l>lowerarm_l': [0.5897, -0.8074, 0.0195], 'lowerarm_l>hand_l': [0.4929, -0.6172, 0.6133],
+    'thigh_l>calf_l': [0.0542, -0.9984, -0.0143], 'calf_l>foot_l': [0.0485, -0.9974, -0.0527], 'foot_l>ball_l': [0.1079, -0.4488, 0.8871],
+    'clavicle_r>upperarm_r': [-0.9957, -0.0845, -0.0386], 'upperarm_r>lowerarm_r': [-0.5897, -0.8074, 0.0195], 'lowerarm_r>hand_r': [-0.4929, -0.6172, 0.6133],
+    'thigh_r>calf_r': [-0.0542, -0.9984, -0.0143], 'calf_r>foot_r': [-0.0485, -0.9974, -0.0527], 'foot_r>ball_r': [-0.1079, -0.4488, 0.8871],
+};
+const r1 = (v) => Math.round(v * 10) / 10;
+const r3 = (v) => Math.round(v * 1000) / 1000;
+const DEG = 180 / Math.PI;
+const FOREARM = /^(lowerarm|hand|thumb|index|middle|ring|pinky)_/;
+const TORSO_HIP = /^(pelvis|spine_0[1-5]|thigh_)/;
+const TORSO_DOM = /^(pelvis|spine_0[1-5]|clavicle_[lr]|neck_0[12])$/;
+const LIMB_DOM = /^(upperarm|lowerarm|hand|thumb|index|middle|ring|pinky|thigh|calf|foot|ball)_/;
+// ------------------------------------------------------------------------------------------------------------ geometry
+/** Per-vertex weight on bones whose name matches `re`. */
+function weightOn(rest, re) {
+    const hit = rest.boneNames.map((n) => re.test(n));
+    const out = new Float32Array(rest.nv);
+    for (let i = 0; i < rest.nv; i++) {
+        let s = 0;
+        for (let k = 0; k < 4; k++)
+            if (hit[rest.skinIndex[i * 4 + k]])
+                s += rest.skinWeight[i * 4 + k];
+        out[i] = s;
+    }
+    return out;
+}
+/** Name of each vertex's dominant bone. */
+function dominantBone(rest) {
+    const out = new Array(rest.nv);
+    for (let i = 0; i < rest.nv; i++) {
+        let bk = 0, bw = -1;
+        for (let k = 0; k < 4; k++) {
+            const w = rest.skinWeight[i * 4 + k];
+            if (w > bw) {
+                bw = w;
+                bk = k;
+            }
+        }
+        out[i] = rest.boneNames[rest.skinIndex[i * 4 + bk]] ?? '';
+    }
+    return out;
+}
+function vertexAreas(P, I, nv) {
+    const va = new Float64Array(nv);
+    for (let t = 0; t + 2 < I.length; t += 3) {
+        const a = I[t] * 3, b = I[t + 1] * 3, c = I[t + 2] * 3;
+        const ux = P[b] - P[a], uy = P[b + 1] - P[a + 1], uz = P[b + 2] - P[a + 2], vx = P[c] - P[a], vy = P[c + 1] - P[a + 1], vz = P[c + 2] - P[a + 2];
+        const ar = Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx) / 6;
+        va[I[t]] += ar;
+        va[I[t + 1]] += ar;
+        va[I[t + 2]] += ar;
+    }
+    return va;
+}
+function vertexNormals(P, I, nv) {
+    const N = new Float32Array(nv * 3);
+    for (let t = 0; t + 2 < I.length; t += 3) {
+        const a = I[t] * 3, b = I[t + 1] * 3, c = I[t + 2] * 3;
+        const ux = P[b] - P[a], uy = P[b + 1] - P[a + 1], uz = P[b + 2] - P[a + 2], vx = P[c] - P[a], vy = P[c + 1] - P[a + 1], vz = P[c + 2] - P[a + 2];
+        const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+        for (const k of [a, b, c]) {
+            N[k] += nx;
+            N[k + 1] += ny;
+            N[k + 2] += nz;
+        }
+    }
+    for (let i = 0; i < nv; i++) {
+        const l = Math.hypot(N[i * 3], N[i * 3 + 1], N[i * 3 + 2]) || 1;
+        N[i * 3] /= l;
+        N[i * 3 + 1] /= l;
+        N[i * 3 + 2] /= l;
+    }
+    return N;
+}
+/** Uniform-grid nearest-neighbour index over a subset of points. */
+class PointGrid {
+    P;
+    cell;
+    cells = new Map();
+    constructor(P, ids, cell = 0.02) {
+        this.P = P;
+        this.cell = cell;
+        for (let k = 0; k < ids.length; k++) {
+            const i = ids[k];
+            const key = this.key(P[i * 3], P[i * 3 + 1], P[i * 3 + 2]);
+            const l = this.cells.get(key);
+            if (l)
+                l.push(i);
+            else
+                this.cells.set(key, [i]);
+        }
+    }
+    key(x, y, z) { return `${Math.floor(x / this.cell)},${Math.floor(y / this.cell)},${Math.floor(z / this.cell)}`; }
+    /** Nearest indexed point within `radius` of (x,y,z): [index, distance] or [-1, Infinity]. */
+    nearest(x, y, z, radius) {
+        const r = Math.ceil(radius / this.cell);
+        const cx = Math.floor(x / this.cell), cy = Math.floor(y / this.cell), cz = Math.floor(z / this.cell);
+        let best = -1, bd = radius * radius;
+        for (let dx = -r; dx <= r; dx++)
+            for (let dy = -r; dy <= r; dy++)
+                for (let dz = -r; dz <= r; dz++) {
+                    const l = this.cells.get(`${cx + dx},${cy + dy},${cz + dz}`);
+                    if (!l)
+                        continue;
+                    for (const j of l) {
+                        const d = (this.P[j * 3] - x) ** 2 + (this.P[j * 3 + 1] - y) ** 2 + (this.P[j * 3 + 2] - z) ** 2;
+                        if (d <= bd) {
+                            bd = d;
+                            best = j;
+                        }
+                    }
+                }
+        return best < 0 ? [-1, Infinity] : [best, Math.sqrt(bd)];
+    }
+    within(x, y, z, radius) {
+        const r = Math.ceil(radius / this.cell);
+        const cx = Math.floor(x / this.cell), cy = Math.floor(y / this.cell), cz = Math.floor(z / this.cell);
+        const out = [];
+        const r2 = radius * radius;
+        for (let dx = -r; dx <= r; dx++)
+            for (let dy = -r; dy <= r; dy++)
+                for (let dz = -r; dz <= r; dz++) {
+                    const l = this.cells.get(`${cx + dx},${cy + dy},${cz + dz}`);
+                    if (!l)
+                        continue;
+                    for (const j of l)
+                        if ((this.P[j * 3] - x) ** 2 + (this.P[j * 3 + 1] - y) ** 2 + (this.P[j * 3 + 2] - z) ** 2 <= r2)
+                            out.push(j);
+                }
+        return out;
+    }
+}
+exports.PointGrid = PointGrid;
+function weld(rest, index, nv, tol = 1e-4) {
+    const map = new Map();
+    const of = new Int32Array(nv);
+    const rep = [];
+    for (let i = 0; i < nv; i++) {
+        const k = `${Math.round(rest[i * 3] / tol)},${Math.round(rest[i * 3 + 1] / tol)},${Math.round(rest[i * 3 + 2] / tol)}`;
+        let w = map.get(k);
+        if (w === undefined) {
+            w = rep.length;
+            map.set(k, w);
+            rep.push(i);
+        }
+        of[i] = w;
+    }
+    const tris = [];
+    for (let t = 0; t + 2 < index.length; t += 3) {
+        const a = of[index[t]], b = of[index[t + 1]], c = of[index[t + 2]];
+        if (a !== b && b !== c && a !== c)
+            tris.push(a, b, c);
+    }
+    return { of, count: rep.length, rep: Int32Array.from(rep), tris: Int32Array.from(tris) };
+}
+function edgeCounts(W) {
+    const m = new Map();
+    const n = W.count;
+    for (let t = 0; t < W.tris.length; t += 3)
+        for (const [a, b] of [[W.tris[t], W.tris[t + 1]], [W.tris[t + 1], W.tris[t + 2]], [W.tris[t + 2], W.tris[t]]]) {
+            const k = Math.min(a, b) * n + Math.max(a, b);
+            m.set(k, (m.get(k) ?? 0) + 1);
+        }
+    return m;
+}
+function adjacency(W) {
+    const adj = Array.from({ length: W.count }, () => []);
+    for (let t = 0; t < W.tris.length; t += 3)
+        for (const [a, b] of [[W.tris[t], W.tris[t + 1]], [W.tris[t + 1], W.tris[t + 2]], [W.tris[t + 2], W.tris[t]]]) {
+            if (!adj[a].includes(b))
+                adj[a].push(b);
+            if (!adj[b].includes(a))
+                adj[b].push(a);
+        }
+    return adj;
+}
+function components(W) {
+    const p = Int32Array.from({ length: W.count }, (_, i) => i);
+    const f = (x) => { while (p[x] !== x) {
+        p[x] = p[p[x]];
+        x = p[x];
+    } return x; };
+    for (let t = 0; t < W.tris.length; t += 3) {
+        const a = f(W.tris[t]);
+        p[f(W.tris[t + 1])] = a;
+        p[f(W.tris[t + 2])] = a;
+    }
+    for (let i = 0; i < W.count; i++)
+        p[i] = f(i);
+    return p;
+}
+/** Forearms/hands buried inside the torso/hips while walking (#3). */
+function measureArmsClear(rest, poses) {
+    const fore = weightOn(rest, FOREARM), body = weightOn(rest, TORSO_HIP);
+    const fi = [], bi = [];
+    for (let i = 0; i < rest.nv; i++) {
+        if (fore[i] >= 0.6)
+            fi.push(i);
+        else if (body[i] >= 0.6)
+            bi.push(i);
+    }
+    if (fi.length < 10 || bi.length < 10 || !poses.length)
+        return { measured: false, why: `${fi.length} forearm/hand and ${bi.length} torso/hip vertices, ${poses.length} poses`, insideShare: 0, peakShare: 0, phase: null, depthCm: 0, forearmVerts: fi.length };
+    const va = vertexAreas(rest.rest, rest.index, rest.nv);
+    let total = 0;
+    for (const i of fi)
+        total += va[i];
+    let best = 0, bestPhase = 0, depth = 0, sum = 0;
+    poses.forEach((ps, pi) => {
+        const P = ps.positions;
+        const N = vertexNormals(P, rest.index, rest.nv);
+        const g = new PointGrid(P, bi, 0.03);
+        let inside = 0, dep = 0;
+        for (const i of fi) {
+            const [j] = g.nearest(P[i * 3], P[i * 3 + 1], P[i * 3 + 2], T.armNearM);
+            if (j < 0)
+                continue;
+            const s = (P[i * 3] - P[j * 3]) * N[j * 3] + (P[i * 3 + 1] - P[j * 3 + 1]) * N[j * 3 + 1] + (P[i * 3 + 2] - P[j * 3 + 2]) * N[j * 3 + 2];
+            if (s < -T.armDepthM) {
+                inside += va[i];
+                dep = Math.max(dep, -s);
+            }
+        }
+        const share = inside / (total || 1);
+        sum += share;
+        if (share > best) {
+            best = share;
+            bestPhase = pi;
+            depth = dep;
+        }
+    });
+    return { measured: true, insideShare: r3(sum / poses.length), peakShare: r3(best), phase: bestPhase, depthCm: r1(depth * 100), forearmVerts: fi.length };
+}
+/** Holes in the surface that open as the limbs swing (#5): the two sides of a hole sit together at rest and part. */
+function measureSurfaceClosed(rest, poses) {
+    if (!poses.length)
+        return { measured: false, why: 'no poses', openCm: 0, boundaryEdges: 0, pairs: 0, phase: null, at: null };
+    const W = weld(rest.rest, rest.index, rest.nv);
+    const ec = edgeCounts(W);
+    const n = W.count;
+    const bset = new Set();
+    let bedges = 0;
+    for (const [k, c] of ec)
+        if (c === 1) {
+            bedges++;
+            bset.add(Math.floor(k / n));
+            bset.add(k % n);
+        }
+    if (!bset.size)
+        return { measured: true, openCm: 0, boundaryEdges: 0, pairs: 0, phase: null, at: null };
+    const comp = components(W);
+    const adj = adjacency(W);
+    const bv = [...bset];
+    const R = rest.rest;
+    const repIdx = bv.map((w) => W.rep[w]);
+    const g = new PointGrid(R, repIdx, T.holePairRestM);
+    const pairs = [];
+    for (const w of bv) {
+        // hop-limited BFS: vertices within (holeMinHops-1) edges are the same side of the boundary, not across a hole.
+        const near = new Set([w]);
+        let front = [w];
+        for (let h = 0; h < T.holeMinHops - 1 && front.length; h++) {
+            const nx = [];
+            for (const u of front)
+                for (const v of adj[u])
+                    if (!near.has(v)) {
+                        near.add(v);
+                        nx.push(v);
+                    }
+            front = nx;
+        }
+        const i = W.rep[w];
+        for (const j of g.within(R[i * 3], R[i * 3 + 1], R[i * 3 + 2], T.holePairRestM)) {
+            const wj = W.of[j];
+            if (wj <= w || near.has(wj) || comp[wj] !== comp[w])
+                continue;
+            pairs.push([i, j, Math.hypot(R[i * 3] - R[j * 3], R[i * 3 + 1] - R[j * 3 + 1], R[i * 3 + 2] - R[j * 3 + 2])]);
+        }
+    }
+    let open = 0, phase = null, at = null;
+    poses.forEach((ps, pi) => {
+        const P = ps.positions;
+        for (const [i, j, d0] of pairs) {
+            const d = Math.hypot(P[i * 3] - P[j * 3], P[i * 3 + 1] - P[j * 3 + 1], P[i * 3 + 2] - P[j * 3 + 2]) - d0;
+            if (d > open) {
+                open = d;
+                phase = pi;
+                at = [r3(R[i * 3]), r3(R[i * 3 + 1]), r3(R[i * 3 + 2])];
+            }
+        }
+    });
+    return { measured: true, openCm: r1(open * 100), boundaryEdges: bedges, pairs: pairs.length, phase, at };
+}
+const col = (m, c) => [m[c * 4], m[c * 4 + 1], m[c * 4 + 2]];
+const pos = (m) => col(m, 3);
+function heightOf(rest) { let lo = Infinity, hi = -Infinity; for (let i = 0; i < rest.nv; i++) {
+    const y = rest.rest[i * 3 + 1];
+    if (y < lo)
+        lo = y;
+    if (y > hi)
+        hi = y;
+} return hi - lo; }
+const CANONICAL = /^(root|pelvis|spine_0[1-5]|neck_0[12]|head|clavicle_[lr]|(upperarm|lowerarm|thigh|calf)(_twist_0\d)?_[lr]|hand_[lr]|foot_[lr]|ball_[lr]|(thumb|index|middle|ring|pinky)_\d\d_[lr])$/;
+/** Per bone: is it hung from the head (the head, the neck, or a non-skeleton bone whose nearest skeleton ancestor is one)? */
+function headHungBones(rest) {
+    return rest.boneNames.map((n, i) => {
+        for (let b = i, guard = 0; b >= 0 && guard < 64; b = rest.parents[b], guard++) {
+            const name = rest.boneNames[b];
+            if (/^(head|neck_0[12])$/.test(name))
+                return true;
+            if (CANONICAL.test(name))
+                return false;
+        }
+        return /hair/i.test(n);
+    });
+}
+/** Hair / cloth / accessories standing out of the torso's outline between the hips and the neck (#2). */
+function measureSilhouette(rest, poses) {
+    const ix = new Map(rest.boneNames.map((n, i) => [n, i]));
+    const s1 = ix.get('spine_01'), nk = ix.get('neck_01');
+    const H = heightOf(rest);
+    const empty = { backCm: 0, sideCm: 0, hairBackCm: 0, hairSideCm: 0, clothBackCm: 0, clothSideCm: 0, phase: null, heightM: r3(H) };
+    if (s1 === undefined || nk === undefined || !poses.length)
+        return { measured: false, why: 'the skeleton has no spine_01/neck_01 to bound the torso', ...empty };
+    const dom = dominantBone(rest);
+    const hung = headHungBones(rest);
+    // 0 torso, 1 hair (hung from the head), 2 cloth/accessory, -1 limb (never judged: an arm swung back is not an outlier)
+    const cls = new Int8Array(rest.nv);
+    for (let i = 0; i < rest.nv; i++) {
+        const n = dom[i];
+        cls[i] = TORSO_DOM.test(n) ? 0 : LIMB_DOM.test(n) ? -1 : hung[ix.get(n) ?? -1] ? 1 : 2;
+    }
+    const scale = 1.7 / (H || 1.7);
+    const worst = { hairBack: 0, hairSide: 0, clothBack: 0, clothSide: 0 };
+    let phase = null;
+    let peak = 0;
+    poses.forEach((ps, pi) => {
+        const P = ps.positions;
+        const lo = pos(ps.bones[s1])[1], hi = pos(ps.bones[nk])[1];
+        const step = 0.02;
+        const nb = Math.max(1, Math.ceil((hi - lo) / step));
+        const mk = () => ({ z: new Float64Array(nb).fill(Infinity), x0: new Float64Array(nb).fill(Infinity), x1: new Float64Array(nb).fill(-Infinity), n: new Int32Array(nb) });
+        const acc = [mk(), mk(), mk()];
+        for (let i = 0; i < rest.nv; i++) {
+            const c = cls[i];
+            if (c < 0)
+                continue;
+            const y = P[i * 3 + 1];
+            if (y < lo || y >= hi)
+                continue;
+            const b = Math.min(nb - 1, Math.floor((y - lo) / step));
+            const x = P[i * 3], z = P[i * 3 + 2];
+            const a = acc[c];
+            a.n[b]++;
+            if (z < a.z[b])
+                a.z[b] = z;
+            if (x < a.x0[b])
+                a.x0[b] = x;
+            if (x > a.x1[b])
+                a.x1[b] = x;
+        }
+        // The torso's outline at a slice is taken over the slice and its neighbours (a slice that catches only a few torso
+        // vertices, e.g. the front of the neck, would otherwise read as a torso with no back).
+        const T0 = acc[0];
+        for (let b = 0; b < nb; b++) {
+            let n = 0, z0 = Infinity, x0 = Infinity, x1 = -Infinity;
+            for (let k = Math.max(0, b - 1); k <= Math.min(nb - 1, b + 1); k++) {
+                n += T0.n[k];
+                z0 = Math.min(z0, T0.z[k]);
+                x0 = Math.min(x0, T0.x0[k]);
+                x1 = Math.max(x1, T0.x1[k]);
+            }
+            if (n < 12)
+                continue;
+            for (const [c, kb, ks] of [[1, 'hairBack', 'hairSide'], [2, 'clothBack', 'clothSide']]) {
+                const a = acc[c];
+                if (!a.n[b])
+                    continue;
+                const bk = (z0 - a.z[b]) * scale, sd = Math.max(a.x1[b] - x1, x0 - a.x0[b]) * scale;
+                if (bk > worst[kb])
+                    worst[kb] = bk;
+                if (sd > worst[ks])
+                    worst[ks] = sd;
+                if (Math.max(bk, sd) > peak) {
+                    peak = Math.max(bk, sd);
+                    phase = pi;
+                }
+            }
+        }
+    });
+    const cm = (v) => r1(v * 100);
+    return { measured: true, backCm: cm(Math.max(worst.hairBack, worst.clothBack)), sideCm: cm(Math.max(worst.hairSide, worst.clothSide)),
+        hairBackCm: cm(worst.hairBack), hairSideCm: cm(worst.hairSide), clothBackCm: cm(worst.clothBack), clothSideCm: cm(worst.clothSide), phase, heightM: r3(H) };
+}
+/** Stray strands on the rest mesh (#4), plus (evidence only) triangles the walk stretches into slivers. */
+function measureStrands(rest, poses) {
+    const W = weld(rest.rest, rest.index, rest.nv);
+    const comp = components(W);
+    const R = rest.rest;
+    const area = new Map();
+    const lo = new Map();
+    const hi = new Map();
+    let total = 0;
+    for (let t = 0; t < W.tris.length; t += 3) {
+        const [a, b, c] = [W.rep[W.tris[t]], W.rep[W.tris[t + 1]], W.rep[W.tris[t + 2]]];
+        const ux = R[b * 3] - R[a * 3], uy = R[b * 3 + 1] - R[a * 3 + 1], uz = R[b * 3 + 2] - R[a * 3 + 2], vx = R[c * 3] - R[a * 3], vy = R[c * 3 + 1] - R[a * 3 + 1], vz = R[c * 3 + 2] - R[a * 3 + 2];
+        const ar = Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx) / 2;
+        total += ar;
+        const k = comp[W.tris[t]];
+        area.set(k, (area.get(k) ?? 0) + ar);
+        for (const v of [a, b, c]) {
+            const l = lo.get(k) ?? [Infinity, Infinity, Infinity];
+            const h = hi.get(k) ?? [-Infinity, -Infinity, -Infinity];
+            for (let d = 0; d < 3; d++) {
+                l[d] = Math.min(l[d], R[v * 3 + d]);
+                h[d] = Math.max(h[d], R[v * 3 + d]);
+            }
+            lo.set(k, l);
+            hi.set(k, h);
+        }
+    }
+    const strands = [];
+    // A thin detached fragment is normal (hair locks, straps, piping); one that floats clear of every other surface is
+    // debris: a stray strand.
+    let others = null;
+    const byComp = new Map();
+    for (let w = 0; w < W.count; w++) {
+        const k = comp[w];
+        const l = byComp.get(k);
+        if (l)
+            l.push(W.rep[w]);
+        else
+            byComp.set(k, [W.rep[w]]);
+    }
+    for (const [k, ar] of area) {
+        const l = lo.get(k), h = hi.get(k);
+        const ext = Math.hypot(h[0] - l[0], h[1] - l[1], h[2] - l[2]);
+        if (!(ext > T.strandMinExtentM && ar / (ext * ext) < T.strandThinness && ar < T.strandMaxShare * total))
+            continue;
+        if (!others)
+            others = new PointGrid(R, Array.from(W.rep), 0.02);
+        const mine = byComp.get(k) ?? [];
+        let gap = Infinity;
+        for (const i of mine) {
+            for (const j of others.within(R[i * 3], R[i * 3 + 1], R[i * 3 + 2], T.strandFloatM))
+                if (comp[W.of[j]] !== k) {
+                    gap = 0;
+                    break;
+                }
+            if (gap === 0)
+                break;
+        }
+        if (gap === 0)
+            continue;
+        strands.push({ extentCm: r1(ext * 100), areaCm2: r1(ar * 1e4), at: [r3((l[0] + h[0]) / 2), r3((l[1] + h[1]) / 2), r3((l[2] + h[2]) / 2)] });
+    }
+    // posed slivers (evidence)
+    const I = rest.index;
+    const L0 = new Float32Array(I.length / 3);
+    const tri = (P, t) => {
+        const a = I[t * 3] * 3, b = I[t * 3 + 1] * 3, c = I[t * 3 + 2] * 3;
+        const e1 = Math.hypot(P[b] - P[a], P[b + 1] - P[a + 1], P[b + 2] - P[a + 2]), e2 = Math.hypot(P[c] - P[b], P[c + 1] - P[b + 1], P[c + 2] - P[b + 2]), e3 = Math.hypot(P[a] - P[c], P[a + 1] - P[c + 1], P[a + 2] - P[c + 2]);
+        const L = Math.max(e1, e2, e3);
+        const ux = P[b] - P[a], uy = P[b + 1] - P[a + 1], uz = P[b + 2] - P[a + 2], vx = P[c] - P[a], vy = P[c + 1] - P[a + 1], vz = P[c + 2] - P[a + 2];
+        return [L, Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx) / (L || 1e-9)];
+    };
+    for (let t = 0; t < L0.length; t++)
+        L0[t] = tri(R, t)[0];
+    let sl = 0, slMax = 0;
+    let slAt = null;
+    for (const ps of poses) {
+        let n = 0;
+        for (let t = 0; t < L0.length; t++) {
+            const [L, h] = tri(ps.positions, t);
+            if (L > 0.04 && h < 0.004 && L > 3 * L0[t]) {
+                n++;
+                if (L > slMax) {
+                    slMax = L;
+                    const a = I[t * 3];
+                    slAt = [r3(R[a * 3]), r3(R[a * 3 + 1]), r3(R[a * 3 + 2])];
+                }
+            }
+        }
+        sl = Math.max(sl, n);
+    }
+    return { strands: strands.sort((a, b) => b.extentCm - a.extentCm).slice(0, 20), components: new Set(comp).size, posedSlivers: sl, posedSliverMaxCm: r1(slMax * 100), posedSliverAt: slAt };
+}
+/** Each canonical bone's bind direction vs the standard skeleton (#6). */
+function measureBindPose(rest) {
+    const ix = new Map(rest.boneNames.map((n, i) => [n, i]));
+    const p = (n) => { const i = ix.get(n); const m = i === undefined ? null : rest.bind[i]; return m ? pos(m) : null; };
+    const abd = {};
+    const delta = {};
+    for (const [key, ref] of Object.entries(exports.STANDARD_BIND_DIRECTIONS)) {
+        const [a, b] = key.split('>');
+        const pa = p(a), pb = p(b);
+        if (!pa || !pb)
+            continue;
+        const v = [pb[0] - pa[0], pb[1] - pa[1], pb[2] - pa[2]];
+        const l = Math.hypot(...v);
+        if (l < 1e-4)
+            continue;
+        const u = v.map((x) => x / l);
+        delta[key] = r1(Math.acos(Math.max(-1, Math.min(1, u[0] * ref[0] + u[1] * ref[1] + u[2] * ref[2]))) * DEG);
+        if (a.startsWith('upperarm_'))
+            abd[a] = r1(Math.acos(Math.max(-1, Math.min(1, -u[1]))) * DEG);
+    }
+    if (!('upperarm_l' in abd) || !('upperarm_r' in abd))
+        return { measured: false, why: 'the skin binds no upperarm_l/lowerarm_l and upperarm_r/lowerarm_r pair', upperarmAbductionDeg: abd, deltaDeg: delta };
+    return { measured: true, upperarmAbductionDeg: abd, deltaDeg: delta };
+}
+/** Head and torso lean through the walk (#7), read from the posed skeleton. */
+function measurePosture(rest, poses) {
+    const ix = new Map(rest.boneNames.map((n, i) => [n, i]));
+    const need = ['pelvis', 'spine_03', 'neck_01', 'head'];
+    if (!poses.length || need.some((n) => !ix.has(n)))
+        return { measured: false, why: `the skeleton lacks ${need.filter((n) => !ix.has(n)).join(', ') || 'poses'}`, neckLeanDeg: null, torsoLeanDeg: null };
+    const lean = (ps, a, b) => { const pa = pos(ps.bones[ix.get(a)]), pb = pos(ps.bones[ix.get(b)]); return Math.atan2(pb[2] - pa[2], pb[1] - pa[1]) * DEG; };
+    const nl = poses.map((ps) => lean(ps, 'neck_01', 'head')), tl = poses.map((ps) => lean(ps, 'pelvis', 'spine_03'));
+    return { measured: true, neckLeanDeg: [r1(Math.min(...nl)), r1(Math.max(...nl))], torsoLeanDeg: [r1(Math.min(...tl)), r1(Math.max(...tl))] };
+}
+const notMeasured = (why, data = {}) => ({ pass: false, detail: `not measured: ${why}`, measured: { ...data, measured: false } });
+function judgeArmsClear(m) {
+    if (!m || !m.measured)
+        return notMeasured(m?.why ?? 'the Marketplace preview walk was never read', { ...m });
+    const ok = m.insideShare <= T.armInsideShareMax;
+    const pc = (v) => (v * 100).toFixed(1);
+    return { pass: ok, measured: { ...m, threshold: T.armInsideShareMax, depthM: T.armDepthM },
+        detail: ok ? `forearms and hands stay out of the body through the walk (${pc(m.insideShare)}% of their surface more than ${T.armDepthM * 100} cm inside the torso/hips on average over the cycle, peak ${pc(m.peakShare)}%; limit ${T.armInsideShareMax * 100}%)`
+            : `the forearms and hands walk INSIDE the body: on average over the walk cycle ${pc(m.insideShare)}% of their surface is more than ${T.armDepthM * 100} cm inside the torso/hips (peak ${pc(m.peakShare)}% at phase ${m.phase}, up to ${m.depthCm} cm deep; limit ${T.armInsideShareMax * 100}%) — the arms are bound too close to the body for the Marketplace walk` };
+}
+function judgeSurfaceClosed(m) {
+    if (!m || !m.measured)
+        return notMeasured(m?.why ?? 'the Marketplace preview walk was never read', { ...m });
+    const ok = m.openCm <= T.holeOpenMaxM * 100;
+    return { pass: ok, measured: { ...m, thresholdCm: T.holeOpenMaxM * 100 },
+        detail: m.boundaryEdges === 0 ? 'the surface is closed (no open boundary edges)'
+            : ok ? `${m.boundaryEdges} open boundary edges; no hole opens as the limbs swing (widest ${m.openCm} cm, limit ${T.holeOpenMaxM * 100} cm)`
+                : `the surface tears open while walking: two sides of a hole that touch at rest (near ${JSON.stringify(m.at)}) part by ${m.openCm} cm at phase ${m.phase} (limit ${T.holeOpenMaxM * 100} cm) — see-through when the limb swings` };
+}
+function judgeSilhouette(m) {
+    if (!m || !m.measured)
+        return notMeasured(m?.why ?? 'the Marketplace preview walk was never read', { ...m });
+    const hl = T.silhouetteHairMaxM * 100, cl = T.silhouetteClothMaxM * 100;
+    const hair = Math.max(m.hairBackCm, m.hairSideCm), cloth = Math.max(m.clothBackCm, m.clothSideCm);
+    const bad = [];
+    if (hair > hl)
+        bad.push(`hair (or something else hung from the head) stands ${m.hairBackCm >= m.hairSideCm ? `${m.hairBackCm} cm off the back` : `${m.hairSideCm} cm out beside the torso`} (limit ${hl} cm)`);
+    if (cloth > cl)
+        bad.push(`cloth or an accessory stands ${m.clothBackCm >= m.clothSideCm ? `${m.clothBackCm} cm off the back` : `${m.clothSideCm} cm out beside the torso`} (limit ${cl} cm)`);
+    return { pass: bad.length === 0, measured: { ...m, thresholdsCm: { hair: hl, cloth: cl } },
+        detail: bad.length ? `something stands out of the body's outline while walking (phase ${m.phase}, at 1.70 m): ${bad.join('; ')}`
+            : `hair stays within ${hair} cm and cloth/accessories within ${cloth} cm of the torso's outline between the hips and the neck (limits ${hl} / ${cl} cm at 1.70 m)` };
+}
+function judgeStrands(m) {
+    if (!m)
+        return notMeasured('the rest mesh was never read');
+    const ok = m.strands.length === 0;
+    return { pass: ok, measured: { ...m },
+        detail: ok ? `no stray strands on the rest mesh (${m.components} connected surfaces)${m.posedSlivers ? `; the walk stretches ${m.posedSlivers} triangle(s) into slivers (longest ${m.posedSliverMaxCm} cm), recorded only` : ''}`
+            : `${m.strands.length} stray strand(s) on the rest mesh: detached thin fragments ${m.strands.slice(0, 3).map((s) => `${s.extentCm} cm long at ${JSON.stringify(s.at)}`).join('; ')}` };
+}
+function judgeBindPose(m) {
+    if (!m || !m.measured)
+        return notMeasured(m?.why ?? 'the skeleton was never read', { ...m });
+    const bad = [];
+    for (const [b, deg] of Object.entries(m.upperarmAbductionDeg))
+        if (deg < T.upperarmAbductionMinDeg)
+            bad.push(`${b} is bound ${deg} deg from the body (standard 36, minimum ${T.upperarmAbductionMinDeg}): the walk's arm swing drives it into the torso`);
+    for (const [k, deg] of Object.entries(m.deltaDeg)) {
+        const cls = k.split('>')[0].replace(/_[lr]$/, '').replace(/_0\d$/, '').replace(/^pelvis$/, 'spine');
+        const lim = T.bindDeltaMaxDeg[cls];
+        if (lim !== undefined && deg > lim)
+            bad.push(`${k.replace('>', '→')} is bound ${deg} deg off the standard skeleton (limit ${lim})`);
+    }
+    return { pass: bad.length === 0, measured: { ...m, thresholds: { upperarmAbductionMinDeg: T.upperarmAbductionMinDeg, bindDeltaMaxDeg: T.bindDeltaMaxDeg } },
+        detail: bad.length ? `bind pose: ${bad.join('; ')}` : `bind pose matches the standard skeleton: upper arms ${Object.values(m.upperarmAbductionDeg).join('/')} deg from the body, worst bone ${Object.entries(m.deltaDeg).sort((a, b) => b[1] - a[1])[0]?.join(' ') ?? '-'} deg` };
+}
+function judgePosture(m) {
+    if (!m || !m.measured || !m.neckLeanDeg || !m.torsoLeanDeg)
+        return notMeasured(m?.why ?? 'the Marketplace preview walk was never read', { ...m });
+    const mid = (r) => (r[0] + r[1]) / 2;
+    const dn = mid(m.neckLeanDeg) - mid(exports.BASE_FEMALE_POSTURE.neckLeanDeg), dt = mid(m.torsoLeanDeg) - mid(exports.BASE_FEMALE_POSTURE.torsoLeanDeg);
+    const bad = [];
+    if (Math.abs(dn) > T.neckLeanDeltaMaxDeg)
+        bad.push(`the head ${dn > 0 ? 'hangs forward' : 'is pulled back'} ${Math.abs(dn).toFixed(0)} deg ${dn > 0 ? 'more' : 'less'} than Base Female's on the same walk (limit ${T.neckLeanDeltaMaxDeg})`);
+    if (Math.abs(dt) > T.torsoLeanDeltaMaxDeg)
+        bad.push(`the torso leans ${Math.abs(dt).toFixed(0)} deg ${dt > 0 ? 'further forward' : 'further back'} than Base Female's (limit ${T.torsoLeanDeltaMaxDeg})`);
+    return { pass: bad.length === 0, measured: { ...m, baseFemale: exports.BASE_FEMALE_POSTURE, neckDeltaDeg: r1(dn), torsoDeltaDeg: r1(dt), thresholds: { neck: T.neckLeanDeltaMaxDeg, torso: T.torsoLeanDeltaMaxDeg } },
+        detail: bad.length ? `posture: ${bad.join('; ')}` : `posture within Base Female's envelope: neck lean ${m.neckLeanDeg.join('..')} deg (BF ${exports.BASE_FEMALE_POSTURE.neckLeanDeg.join('..')}), torso ${m.torsoLeanDeg.join('..')} deg` };
+}
+/** Phases at which each arm swings furthest back (hand furthest behind the pelvis), for the critic's frames. */
+function backswingPhases(rest, poses) {
+    const ix = new Map(rest.boneNames.map((n, i) => [n, i]));
+    const pick = (hand) => {
+        const h = ix.get(hand), p = ix.get('pelvis');
+        if (h === undefined || p === undefined || !poses.length)
+            return null;
+        let best = 0, bz = Infinity;
+        poses.forEach((ps, i) => { const z = pos(ps.bones[h])[2] - pos(ps.bones[p])[2]; if (z < bz) {
+            bz = z;
+            best = i;
+        } });
+        return best;
+    };
+    return { left: pick('hand_l'), right: pick('hand_r') };
+}
+/** Body-frame bounds of every posed vertex over the given poses. */
+function posedBounds(poses) {
+    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+    for (const ps of poses)
+        for (let i = 0; i + 2 < ps.positions.length; i += 3)
+            for (let k = 0; k < 3; k++) {
+                const v = ps.positions[i + k];
+                if (!Number.isFinite(v))
+                    continue;
+                if (v < min[k])
+                    min[k] = v;
+                if (v > max[k])
+                    max[k] = v;
+            }
+    return Number.isFinite(min[0]) ? { min, max } : null;
+}
+//# sourceMappingURL=avatarPreviewMath.js.map