@hypersoniclabs/helix-cli 0.1.7 → 0.1.23

package/dist/character/stages/limbBridge.js

@@ -0,0 +1,1286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limbOfJoint = limbOfJoint;
+exports.stretchedAreaPercent = stretchedAreaPercent;
+exports.limbSegments = limbSegments;
+exports.repairLimbBridges = repairLimbBridges;
+exports.baseColorLumaSamplers = baseColorLumaSamplers;
+exports.describeLimbBridgeReport = describeLimbBridgeReport;
+const mat4_1 = require("../mat4");
+const posing_1 = require("./poseFit/posing");
+const LIMBS = ['arm_l', 'arm_r', 'leg_l', 'leg_r'];
+const isArm = (limb) => limb === 0 || limb === 1;
+const isLeg = (limb) => limb === 2 || limb === 3;
+/** helix-humanoid@1 joint -> limb, or null for torso/head/clavicle/root joints. */
+function limbOfJoint(name) {
+    const arm = /^(?:upperarm|lowerarm|hand|thumb|index|middle|ring|pinky)(?:_[a-z0-9]+)*_([lr])$/.exec(name);
+    if (arm)
+        return arm[1] === 'l' ? 'arm_l' : 'arm_r';
+    const leg = /^(?:thigh|calf|foot|ball)(?:_[a-z0-9]+)*_([lr])$/.exec(name);
+    if (leg)
+        return leg[1] === 'l' ? 'leg_l' : 'leg_r';
+    return null;
+}
+function weldPositions(pos, n) {
+    const ids = new Map();
+    const weld = new Int32Array(n);
+    for (let v = 0; v < n; v++) {
+        const key = `${pos[v * 3]},${pos[v * 3 + 1]},${pos[v * 3 + 2]}`;
+        let id = ids.get(key);
+        if (id === undefined) {
+            id = ids.size;
+            ids.set(key, id);
+        }
+        weld[v] = id;
+    }
+    return { weld, welds: ids.size };
+}
+const edgeKey = (a, b) => (a < b ? a * 0x200000 + b : b * 0x200000 + a);
+// ── stride gate ────────────────────────────────────────────────────────────────────────────────────────────
+function rotationAboutX(angle, pivot) {
+    const c = Math.cos(angle), s = Math.sin(angle);
+    const py = pivot[1], pz = pivot[2];
+    // T(p) · Rx · T(-p), column-major: translation = p - Rx·p.
+    return [1, 0, 0, 0, 0, c, s, 0, 0, -s, c, 0, 0, py - (c * py - s * pz), pz - (s * py + c * pz), 1];
+}
+/** Skinning matrices for the two gate strides (index 0: left leg forward, 1: right leg forward). */
+function strideMatrices(node, strideDeg) {
+    const skin = node.getSkin();
+    if (!skin)
+        return null;
+    const joints = skin.listJoints();
+    const ibm = skin.getInverseBindMatrices();
+    const swing = [[/^thigh_l$/, 1], [/^thigh_r$/, -1], [/^upperarm_l$/, -0.85], [/^upperarm_r$/, 0.85]];
+    const roots = new Map();
+    for (const joint of joints)
+        for (const [re, sign] of swing)
+            if (re.test(joint.getName()))
+                roots.set(joint, sign);
+    if (roots.size === 0)
+        return null;
+    const angle = (strideDeg * Math.PI) / 180;
+    const build = (phase) => joints.map((joint, i) => {
+        let delta = null;
+        for (let n = joint; n !== null; n = n.getParentNode()) {
+            const sign = roots.get(n);
+            if (sign !== undefined) {
+                const w = n.getWorldMatrix();
+                delta = rotationAboutX(phase * sign * angle, [w[12], w[13], w[14]]);
+                break;
+            }
+        }
+        const world = joint.getWorldMatrix();
+        const inv = ibm ? ibm.getElement(i, new Array(16).fill(0)) : [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        return (0, mat4_1.mul4)(delta ? (0, mat4_1.mul4)(delta, world) : world, inv);
+    });
+    return [build(1), build(-1)];
+}
+function skinPositions(pos, n, inf, mats) {
+    const out = new Float64Array(n * 3);
+    for (let v = 0; v < n; v++) {
+        const x = pos[v * 3], y = pos[v * 3 + 1], z = pos[v * 3 + 2];
+        let sum = 0;
+        for (let k = 0; k < 8; k++) {
+            const w = inf.weights[v * 8 + k];
+            const j = inf.joints[v * 8 + k];
+            if (w <= 0 || j < 0)
+                continue;
+            const m = mats[j];
+            sum += w;
+            out[v * 3] += w * (m[0] * x + m[4] * y + m[8] * z + m[12]);
+            out[v * 3 + 1] += w * (m[1] * x + m[5] * y + m[9] * z + m[13]);
+            out[v * 3 + 2] += w * (m[2] * x + m[6] * y + m[10] * z + m[14]);
+        }
+        if (sum > 0) {
+            out[v * 3] /= sum;
+            out[v * 3 + 1] /= sum;
+            out[v * 3 + 2] /= sum;
+        }
+        else {
+            out[v * 3] = x;
+            out[v * 3 + 1] = y;
+            out[v * 3 + 2] = z;
+        }
+    }
+    return out;
+}
+/** Percent of triangle area with any edge stretched over 3x between `rest` and `posed`. */
+function stretchedAreaPercent(rest, posed, tris) {
+    let total = 0, torn = 0;
+    const len = (p, a, b) => Math.hypot(p[a * 3] - p[b * 3], p[a * 3 + 1] - p[b * 3 + 1], p[a * 3 + 2] - p[b * 3 + 2]);
+    for (let t = 0; t < tris.length; t += 3) {
+        const a = tris[t], b = tris[t + 1], c = tris[t + 2];
+        const ux = rest[b * 3] - rest[a * 3], uy = rest[b * 3 + 1] - rest[a * 3 + 1], uz = rest[b * 3 + 2] - rest[a * 3 + 2];
+        const vx = rest[c * 3] - rest[a * 3], vy = rest[c * 3 + 1] - rest[a * 3 + 1], vz = rest[c * 3 + 2] - rest[a * 3 + 2];
+        const area = 0.5 * Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx);
+        total += area;
+        let worst = 0;
+        for (const [i, j] of [[a, b], [b, c], [c, a]]) {
+            const r = len(rest, i, j);
+            if (r > 1e-7)
+                worst = Math.max(worst, len(posed, i, j) / r);
+        }
+        if (worst > 3)
+            torn += area;
+    }
+    return total > 0 ? (100 * torn) / total : 0;
+}
+const DEBRIS_TRIS = 8;
+/** A piece only a bridge holds on is re-assigned to the limb it hangs from only when it is hand-sized. */
+const MAX_REASSIGNED_PIECE_M = 0.2;
+/** Bridge triangles (an arm-owned corner and a leg-owned corner), grouped into clusters by shared welded vertices. */
+function detectBridges(index, weld, pos, label) {
+    const triCount = index.length / 3;
+    const cluster = new Int32Array(triCount).fill(-1);
+    const bridge = [];
+    for (let t = 0; t < triCount; t++) {
+        const ls = [label[index[t * 3]], label[index[t * 3 + 1]], label[index[t * 3 + 2]]];
+        if (ls.some(isArm) && ls.some(isLeg))
+            bridge.push(t);
+    }
+    const parent = new Map();
+    const find = (x) => { let r = x; while (parent.get(r) !== r)
+        r = parent.get(r); parent.set(x, r); return r; };
+    const byWeld = new Map();
+    for (const t of bridge) {
+        parent.set(t, t);
+        for (let k = 0; k < 3; k++) {
+            const w = weld[index[t * 3 + k]];
+            const other = byWeld.get(w);
+            if (other === undefined)
+                byWeld.set(w, t);
+            else
+                parent.set(find(t), find(other));
+        }
+    }
+    const ids = new Map();
+    const clusters = [];
+    const votes = [];
+    for (const t of bridge) {
+        const root = find(t);
+        let id = ids.get(root);
+        if (id === undefined) {
+            id = clusters.length;
+            ids.set(root, id);
+            clusters.push({ arm: 'arm_l', leg: 'leg_l', triangles: 0, min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity], refused: null });
+            votes.push(new Map());
+        }
+        cluster[t] = id;
+        const c = clusters[id];
+        c.triangles++;
+        const ls = [0, 1, 2].map((k) => label[index[t * 3 + k]]);
+        const pair = `${LIMBS[ls.find(isArm)]}|${LIMBS[ls.find(isLeg)]}`;
+        votes[id].set(pair, (votes[id].get(pair) ?? 0) + 1);
+        for (let k = 0; k < 3; k++) {
+            const v = index[t * 3 + k];
+            for (let a = 0; a < 3; a++) {
+                c.min[a] = Math.min(c.min[a], pos[v * 3 + a]);
+                c.max[a] = Math.max(c.max[a], pos[v * 3 + a]);
+            }
+        }
+    }
+    clusters.forEach((c, i) => {
+        const [arm, leg] = [...votes[i].entries()].sort((a, b) => b[1] - a[1])[0][0].split('|');
+        c.arm = arm;
+        c.leg = leg;
+        c.min = c.min.map((x) => Math.round(x * 1000) / 1000);
+        c.max = c.max.map((x) => Math.round(x * 1000) / 1000);
+    });
+    return { cluster, clusters };
+}
+/** Union-find root per welded vertex over the triangles not in `removed` (null = all). */
+function componentRoots(index, weld, welds, removed) {
+    const parent = new Int32Array(welds);
+    for (let i = 0; i < welds; i++)
+        parent[i] = i;
+    const find = (x) => { while (parent[x] !== x) {
+        parent[x] = parent[parent[x]];
+        x = parent[x];
+    } return x; };
+    for (let t = 0; t < index.length / 3; t++) {
+        if (removed && removed[t])
+            continue;
+        const a = find(weld[index[t * 3]]), b = find(weld[index[t * 3 + 1]]);
+        parent[b] = a;
+        const c = find(weld[index[t * 3 + 2]]);
+        parent[c] = find(a);
+    }
+    for (let i = 0; i < welds; i++)
+        parent[i] = find(i);
+    return parent;
+}
+/** Triangle groups that removing `removed` splits off the component they belonged to (the largest part stays). */
+function detachedPieces(index, weld, welds, removed, baseRoot) {
+    const after = componentRoots(index, weld, welds, removed);
+    const groups = new Map();
+    for (let t = 0; t < index.length / 3; t++) {
+        if (removed[t])
+            continue;
+        const r = after[weld[index[t * 3]]];
+        (groups.get(r) ?? groups.set(r, []).get(r)).push(t);
+    }
+    const byBase = new Map();
+    for (const tris of groups.values()) {
+        const b = baseRoot[weld[index[tris[0] * 3]]];
+        (byBase.get(b) ?? byBase.set(b, []).get(b)).push(tris);
+    }
+    const pieces = [];
+    for (const parts of byBase.values()) {
+        if (parts.length < 2)
+            continue;
+        parts.sort((a, b) => b.length - a.length);
+        pieces.push(...parts.slice(1));
+    }
+    return pieces;
+}
+function extendInfluences(inf, sources) {
+    const count = inf.count + sources.length;
+    const joints = new Int32Array(count * 8).fill(-1);
+    const weights = new Float64Array(count * 8);
+    const dominant = new Int32Array(count).fill(-1);
+    joints.set(inf.joints);
+    weights.set(inf.weights);
+    dominant.set(inf.dominant);
+    sources.forEach((s, i) => {
+        joints.set(inf.joints.subarray(s * 8, s * 8 + 8), (inf.count + i) * 8);
+        weights.set(inf.weights.subarray(s * 8, s * 8 + 8), (inf.count + i) * 8);
+        dominant[inf.count + i] = inf.dominant[s];
+    });
+    return { count, joints, weights, dominant };
+}
+/**
+ * Ear clipping in the loop's own best-fit plane (Newell normal): only convex ears with no other loop vertex inside
+ * are cut, shortest diagonal first, so a cap never folds back over itself (a folded cap faces inward and renders as a
+ * dark shard). A loop too twisted to project cleanly falls back to the shortest convex, then shortest, diagonal.
+ * Triangles keep the ring's winding.
+ */
+function earClip(loop, P, out) {
+    const ring = loop.slice();
+    if (ring.length < 3)
+        return;
+    let nx = 0, ny = 0, nz = 0;
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i], b = ring[(i + 1) % ring.length];
+        nx += (P[a * 3 + 1] - P[b * 3 + 1]) * (P[a * 3 + 2] + P[b * 3 + 2]);
+        ny += (P[a * 3 + 2] - P[b * 3 + 2]) * (P[a * 3] + P[b * 3]);
+        nz += (P[a * 3] - P[b * 3]) * (P[a * 3 + 1] + P[b * 3 + 1]);
+    }
+    const nl = Math.hypot(nx, ny, nz) || 1;
+    nx /= nl;
+    ny /= nl;
+    nz /= nl;
+    // In-plane basis (u, v) with u x v = n, so the ring runs counter-clockwise in (u, v).
+    let [ux, uy, uz] = Math.abs(nx) < 0.9 ? [0, -nz, ny] : [-nz, 0, nx];
+    const ul = Math.hypot(ux, uy, uz) || 1;
+    ux /= ul;
+    uy /= ul;
+    uz /= ul;
+    const vx = ny * uz - nz * uy, vy = nz * ux - nx * uz, vz = nx * uy - ny * ux;
+    const U = (v) => P[v * 3] * ux + P[v * 3 + 1] * uy + P[v * 3 + 2] * uz;
+    const V = (v) => P[v * 3] * vx + P[v * 3 + 1] * vy + P[v * 3 + 2] * vz;
+    const cross = (a, b, c) => (U(b) - U(a)) * (V(c) - V(a)) - (V(b) - V(a)) * (U(c) - U(a));
+    const inside = (p, a, b, c) => cross(a, b, p) > 0 && cross(b, c, p) > 0 && cross(c, a, p) > 0;
+    const d = (a, b) => Math.hypot(P[a * 3] - P[b * 3], P[a * 3 + 1] - P[b * 3 + 1], P[a * 3 + 2] - P[b * 3 + 2]);
+    while (ring.length > 3) {
+        let best = -1, bestLen = Infinity, convex = -1, convexLen = Infinity, any = 0, anyLen = Infinity;
+        for (let i = 0; i < ring.length; i++) {
+            const a = ring[(i + ring.length - 1) % ring.length], b = ring[i], c = ring[(i + 1) % ring.length];
+            const l = d(a, c);
+            if (l < anyLen) {
+                anyLen = l;
+                any = i;
+            }
+            if (cross(a, b, c) <= 0)
+                continue;
+            if (l < convexLen) {
+                convexLen = l;
+                convex = i;
+            }
+            if (l >= bestLen)
+                continue;
+            let clear = true;
+            for (const p of ring)
+                if (p !== a && p !== b && p !== c && inside(p, a, b, c)) {
+                    clear = false;
+                    break;
+                }
+            if (clear) {
+                bestLen = l;
+                best = i;
+            }
+        }
+        const i = best >= 0 ? best : convex >= 0 ? convex : any;
+        out.push(ring[(i + ring.length - 1) % ring.length], ring[i], ring[(i + 1) % ring.length]);
+        ring.splice(i, 1);
+    }
+    out.push(ring[0], ring[1], ring[2]);
+}
+function planRepair(surface, index, inf, jointLimb, cluster, accepted, cleanseRadius, 
+/** Per vertex: 1 arm side, 2 leg side, 0 neither (from labels, with re-assigned pieces already applied). */
+vertexSide, 
+/** Vertices whose whole weight must follow `vertexSide` wherever they are (re-assigned pieces). */
+forced, 
+/** Limb label per vertex (index into LIMBS, -1 none). */
+label, 
+/** "arm|leg" limb-index pairs of the accepted clusters and re-assigned pieces. */
+pairs, 
+/** Base-colour luminance at a vertex's texture coordinate, when the texture could be decoded. */
+lumaOf) {
+    const { n, pos } = surface;
+    const keep = [];
+    const cutWelds = new Set();
+    const edgeCluster = new Map();
+    for (let t = 0; t < index.length / 3; t++) {
+        const c = cluster[t];
+        if (c >= 0 && accepted.has(c)) {
+            for (let k = 0; k < 3; k++) {
+                const a = index[t * 3 + k], b = index[t * 3 + ((k + 1) % 3)];
+                cutWelds.add(surface.weld[a]);
+                edgeCluster.set(edgeKey(surface.weld[a], surface.weld[b]), c);
+            }
+            continue;
+        }
+        keep.push(index[t * 3], index[t * 3 + 1], index[t * 3 + 2]);
+    }
+    const sideOfVertex = (v) => vertexSide[v];
+    // 2. Bow-ties: at each cut position, group the kept triangles around it into edge-connected fans.
+    let weld = surface.weld;
+    const dups = [];
+    const welds0 = surface.welds;
+    let nextWeld = welds0;
+    const incident = new Map();
+    for (let t = 0; t < keep.length / 3; t++)
+        for (let k = 0; k < 3; k++) {
+            const w = weld[keep[t * 3 + k]];
+            if (!cutWelds.has(w))
+                continue;
+            (incident.get(w) ?? incident.set(w, []).get(w)).push(t);
+        }
+    const weldOverride = new Map(); // vertex (incl. dups) -> weld id
+    const weldOf = (v) => weldOverride.get(v) ?? (v < n ? weld[v] : -1);
+    for (const [w, list] of incident) {
+        if (list.length < 2)
+            continue;
+        const parent = list.map((_, i) => i);
+        const find = (x) => { while (parent[x] !== x)
+            x = parent[x] = parent[parent[x]]; return x; };
+        const others = list.map((t) => [0, 1, 2].map((k) => weld[keep[t * 3 + k]]).filter((x) => x !== w));
+        for (let i = 0; i < list.length; i++)
+            for (let j = i + 1; j < list.length; j++) {
+                if (others[i].some((x) => others[j].includes(x)))
+                    parent[find(j)] = find(i);
+            }
+        const fans = new Map();
+        list.forEach((t, i) => { const r = find(i); (fans.get(r) ?? fans.set(r, []).get(r)).push(t); });
+        if (fans.size < 2)
+            continue;
+        const fanList = [...fans.values()];
+        // The fan whose other corners are mostly on one side keeps the original; every other fan gets a copy.
+        for (const fan of fanList.slice(1)) {
+            const newWeld = nextWeld++;
+            const remap = new Map();
+            let cx = 0, cy = 0, cz = 0, cnt = 0;
+            for (const t of fan)
+                for (let k = 0; k < 3; k++) {
+                    const v = keep[t * 3 + k];
+                    if (weld[v] === w)
+                        continue;
+                    cx += pos[v * 3];
+                    cy += pos[v * 3 + 1];
+                    cz += pos[v * 3 + 2];
+                    cnt++;
+                }
+            for (const t of fan)
+                for (let k = 0; k < 3; k++) {
+                    const v = keep[t * 3 + k];
+                    if (v >= n || weld[v] !== w)
+                        continue;
+                    let copy = remap.get(v);
+                    if (copy === undefined) {
+                        const p = [pos[v * 3], pos[v * 3 + 1], pos[v * 3 + 2]];
+                        if (cnt > 0) {
+                            const dx = cx / cnt - p[0], dy = cy / cnt - p[1], dz = cz / cnt - p[2];
+                            const d = Math.hypot(dx, dy, dz);
+                            if (d > 0) {
+                                p[0] += (dx / d) * 1e-4;
+                                p[1] += (dy / d) * 1e-4;
+                                p[2] += (dz / d) * 1e-4;
+                            }
+                        }
+                        copy = n + dups.length;
+                        dups.push({ source: v, pos: p });
+                        remap.set(v, copy);
+                        weldOverride.set(copy, newWeld);
+                    }
+                    keep[t * 3 + k] = copy;
+                }
+        }
+    }
+    let total = n + dups.length;
+    let P = new Float32Array(total * 3);
+    P.set(pos.subarray(0, n * 3));
+    dups.forEach((d, i) => P.set(d.pos, (n + i) * 3));
+    let W = new Int32Array(total);
+    for (let v = 0; v < total; v++)
+        W[v] = weldOf(v);
+    weld = W;
+    // 3. New boundary loops: directed boundary edges of the kept surface that were interior before the cut.
+    const edgeUse = new Map();
+    for (let t = 0; t < keep.length; t += 3)
+        for (let k = 0; k < 3; k++) {
+            const key = edgeKey(weld[keep[t + k]], weld[keep[t + ((k + 1) % 3)]]);
+            edgeUse.set(key, (edgeUse.get(key) ?? 0) + 1);
+        }
+    const origWeldOf = (wid, v) => (wid < welds0 ? wid : surface.weld[v < n ? v : dups[v - n].source]);
+    // Hole traversal: a boundary edge a->b of a kept triangle is walked b->a by the hole.
+    const next = new Map();
+    let failed = -1;
+    for (let t = 0; t < keep.length; t += 3)
+        for (let k = 0; k < 3; k++) {
+            const va = keep[t + k], vb = keep[t + ((k + 1) % 3)];
+            const a = weld[va], b = weld[vb];
+            if (edgeUse.get(edgeKey(a, b)) !== 1)
+                continue;
+            const c = edgeCluster.get(edgeKey(origWeldOf(a, va), origWeldOf(b, vb)));
+            if (c === undefined)
+                continue; // a pre-existing border (cuff, neckline) — never filled
+            if (next.has(b)) {
+                failed = c;
+                continue;
+            }
+            next.set(b, { to: a, vertex: vb, cluster: c });
+        }
+    const fill = [];
+    let holes = 0;
+    const seen = new Set();
+    for (const start of next.keys()) {
+        if (seen.has(start))
+            continue;
+        const loop = []; // vertex indices
+        let w = start, guard = 0, closed = false, c = -1;
+        while (guard++ < 100000) {
+            const step = next.get(w);
+            if (!step)
+                break;
+            c = step.cluster;
+            seen.add(w);
+            loop.push(step.vertex);
+            w = step.to;
+            if (w === start) {
+                closed = true;
+                break;
+            }
+            if (seen.has(w))
+                break;
+        }
+        if (!closed) {
+            failed = failed >= 0 ? failed : c;
+            continue;
+        }
+        holes++;
+        const holeStart = fill.length;
+        // A loop that runs through unowned vertices can carry an arm-owned stretch and a leg-owned stretch: close
+        // each owned run against its flanking unowned vertices first, so no fill triangle joins an arm to a leg.
+        const cls = (v) => { const l = label[v < n ? v : dups[v - n].source]; return isArm(l) ? 1 : isLeg(l) ? 2 : 0; };
+        let ring = loop.slice();
+        if (ring.some((v) => cls(v) === 1) && ring.some((v) => cls(v) === 2)) {
+            const shift = ring.findIndex((v) => cls(v) === 0);
+            ring = [...ring.slice(shift), ...ring.slice(0, shift)];
+            const rest = [];
+            for (let i = 0; i < ring.length;) {
+                if (cls(ring[i]) === 0) {
+                    rest.push(ring[i]);
+                    i++;
+                    continue;
+                }
+                let j = i;
+                while (j < ring.length && cls(ring[j]) !== 0)
+                    j++;
+                earClip([ring[i - 1], ...ring.slice(i, j), ring[j % ring.length]], P, fill);
+                i = j;
+            }
+            ring = rest;
+        }
+        earClip(ring, P, fill);
+        // The fill gets its own copies of the loop vertices (same position, same weld, same weights) that all sample
+        // one texel — the loop vertex nearest the hole's centre — instead of interpolating across atlas charts.
+        let cx = 0, cy = 0, cz = 0;
+        for (const v of loop) {
+            cx += P[v * 3];
+            cy += P[v * 3 + 1];
+            cz += P[v * 3 + 2];
+        }
+        cx /= loop.length;
+        cy /= loop.length;
+        cz /= loop.length;
+        let rep = loop[0], repD = Infinity;
+        for (const v of loop) {
+            const dd = Math.hypot(P[v * 3] - cx, P[v * 3 + 1] - cy, P[v * 3 + 2] - cz);
+            if (dd < repD) {
+                repD = dd;
+                rep = v;
+            }
+        }
+        const root = (v) => (v < n ? v : dups[v - n].source);
+        if (lumaOf) {
+            // With the texture at hand, the patch takes the rim's MEDIAN brightness: a seam line or a baked fold shadow
+            // under the nearest vertex would paint the whole cap dark.
+            const ranked = loop.map((v) => [v, lumaOf(root(v))]).filter(([, l]) => Number.isFinite(l)).sort((x, y) => x[1] - y[1]);
+            if (ranked.length > 0)
+                rep = ranked[Math.floor(ranked.length / 2)][0];
+        }
+        const copies = new Map();
+        for (let i = holeStart; i < fill.length; i++) {
+            const v = fill[i];
+            let copy = copies.get(v);
+            if (copy === undefined) {
+                copy = n + dups.length;
+                dups.push({ source: root(v), pos: [P[v * 3], P[v * 3 + 1], P[v * 3 + 2]], uvFrom: root(rep) });
+                weldOverride.set(copy, weld[v]);
+                copies.set(v, copy);
+            }
+            fill[i] = copy;
+        }
+    }
+    total = n + dups.length;
+    P = new Float32Array(total * 3);
+    P.set(pos.subarray(0, n * 3));
+    dups.forEach((d, i) => P.set(d.pos, (n + i) * 3));
+    W = new Int32Array(total);
+    for (let v = 0; v < total; v++)
+        W[v] = weldOf(v);
+    weld = W;
+    if (failed >= 0)
+        return { tris: new Uint32Array(0), dups, inf, fillTris: 0, holes: 0, reweighted: 0, failedCluster: failed };
+    const tris = new Uint32Array(keep.length + fill.length);
+    tris.set(keep);
+    tris.set(fill, keep.length);
+    // 4. Cleanse cross-limb weight near the cut: two multi-source Dijkstra fronts over the repaired surface.
+    const out = extendInfluences(inf, dups.map((d) => d.source));
+    const adj = new Map();
+    const link = (a, b) => {
+        const wa = weld[a], wb = weld[b];
+        if (wa === wb)
+            return;
+        const l = Math.hypot(P[a * 3] - P[b * 3], P[a * 3 + 1] - P[b * 3 + 1], P[a * 3 + 2] - P[b * 3 + 2]);
+        (adj.get(wa) ?? adj.set(wa, new Map()).get(wa)).set(wb, l);
+        (adj.get(wb) ?? adj.set(wb, new Map()).get(wb)).set(wa, l);
+    };
+    for (let t = 0; t < tris.length; t += 3) {
+        link(tris[t], tris[t + 1]);
+        link(tris[t + 1], tris[t + 2]);
+        link(tris[t + 2], tris[t]);
+    }
+    const weldVerts = new Map();
+    for (let v = 0; v < total; v++)
+        (weldVerts.get(weld[v]) ?? weldVerts.set(weld[v], []).get(weld[v])).push(v);
+    const front = (side) => {
+        const dist = new Map();
+        const queue = [];
+        for (const [wid, vs] of weldVerts) {
+            const orig = origWeldOf(wid, vs[0]);
+            if (!cutWelds.has(orig))
+                continue;
+            if (!adj.has(wid))
+                continue;
+            if (vs.some((v) => sideOfVertex(v < n ? v : dups[v - n].source) === side)) {
+                dist.set(wid, 0);
+                queue.push([0, wid]);
+            }
+        }
+        // Small graphs: a sorted array queue is enough (the zone is a few thousand vertices).
+        while (queue.length > 0) {
+            queue.sort((x, y) => y[0] - x[0]);
+            const [dw, wid] = queue.pop();
+            if (dw > (dist.get(wid) ?? Infinity))
+                continue;
+            for (const [nb, l] of adj.get(wid) ?? []) {
+                const nd = dw + l;
+                if (nd > cleanseRadius || nd >= (dist.get(nb) ?? Infinity))
+                    continue;
+                dist.set(nb, nd);
+                queue.push([nd, nb]);
+            }
+        }
+        return dist;
+    };
+    const armDist = front(1), legDist = front(2);
+    const zone = new Set([...armDist.keys(), ...legDist.keys()]);
+    // Limbs on each side of the accepted cuts: a vertex owned by one of them (anywhere on the mesh) drops the
+    // limbs it was cut from; an unowned vertex within the cleanse radius sides with the nearer cut edge.
+    const pairedArms = new Set(), pairedLegs = new Set();
+    for (const pair of pairs) {
+        const [a, l] = pair.split('|').map(Number);
+        pairedArms.add(a);
+        pairedLegs.add(l);
+    }
+    let reweighted = 0;
+    const orphans = [];
+    for (let v = 0; v < total; v++) {
+        const src = v < n ? v : dups[v - n].source;
+        const own = label[src];
+        let side = 0;
+        if (forced.has(src))
+            side = sideOfVertex(src);
+        else if (own >= 0 && (pairedArms.has(own) || pairedLegs.has(own)))
+            side = isArm(own) ? 1 : 2;
+        else if (zone.has(weld[v])) {
+            const da = armDist.get(weld[v]) ?? Infinity, dl = legDist.get(weld[v]) ?? Infinity;
+            side = da < dl ? 1 : dl < da ? 2 : sideOfVertex(src);
+        }
+        if (side === 0)
+            continue;
+        const drop = side === 1 ? pairedLegs : pairedArms;
+        let changed = false, sum = 0;
+        for (let k = 0; k < 8; k++) {
+            const j = out.joints[v * 8 + k], w = out.weights[v * 8 + k];
+            if (j < 0 || w <= 0)
+                continue;
+            if (drop.has(jointLimb[j])) {
+                out.weights[v * 8 + k] = 0;
+                out.joints[v * 8 + k] = -1;
+                changed = true;
+                continue;
+            }
+            sum += w;
+        }
+        if (!changed)
+            continue;
+        reweighted++;
+        if (sum < 1e-4) {
+            orphans.push(v);
+            continue;
+        }
+        for (let k = 0; k < 8; k++)
+            out.weights[v * 8 + k] /= sum;
+    }
+    // Orphans (a hand vertex that carried only thigh weight) inherit their cleansed neighbours' blend.
+    const vertexNeighbours = (v) => [...(adj.get(weld[v])?.keys() ?? [])].flatMap((wid) => weldVerts.get(wid) ?? []);
+    let pending = orphans;
+    for (let pass = 0; pass < 64 && pending.length > 0; pass++) {
+        const stillPending = [];
+        const resolved = [];
+        const isPending = new Set(pending);
+        for (const v of pending) {
+            const acc = new Map();
+            for (const u of vertexNeighbours(v)) {
+                if (isPending.has(u))
+                    continue;
+                for (let k = 0; k < 8; k++) {
+                    const j = out.joints[u * 8 + k], w = out.weights[u * 8 + k];
+                    if (j >= 0 && w > 0)
+                        acc.set(j, (acc.get(j) ?? 0) + w);
+                }
+            }
+            if (acc.size === 0)
+                stillPending.push(v);
+            else
+                resolved.push([v, acc]);
+        }
+        for (const [v, acc] of resolved) {
+            const top = [...acc.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4);
+            const s = top.reduce((x, [, w]) => x + w, 0);
+            for (let k = 0; k < 8; k++) {
+                out.joints[v * 8 + k] = -1;
+                out.weights[v * 8 + k] = 0;
+            }
+            top.forEach(([j, w], k) => { out.joints[v * 8 + k] = j; out.weights[v * 8 + k] = w / s; });
+        }
+        if (stillPending.length === pending.length)
+            break;
+        pending = stillPending;
+    }
+    if (pending.length > 0) {
+        // Nothing to inherit from: keep the source blend rather than leave a weightless vertex.
+        for (const v of pending) {
+            const src = v < n ? v : dups[v - n].source;
+            out.joints.set(inf.joints.subarray(src * 8, src * 8 + 8), v * 8);
+            out.weights.set(inf.weights.subarray(src * 8, src * 8 + 8), v * 8);
+        }
+    }
+    return { tris, dups, inf: out, fillTris: fill.length / 3, holes, reweighted, failedCluster: -1 };
+}
+function setAccessorArray(prim, semantic, accessor, array) {
+    const sharedElsewhere = accessor.listParents().some((p) => p !== prim && p.propertyType !== 'Root');
+    if (sharedElsewhere) {
+        const copy = accessor.clone().setArray(array);
+        if (semantic === '__indices')
+            prim.setIndices(copy);
+        else
+            prim.setAttribute(semantic, copy);
+    }
+    else
+        accessor.setArray(array);
+}
+function appendElements(accessor, sources, overridePos) {
+    const src = accessor.getArray();
+    const size = accessor.getElementSize();
+    const Ctor = src.constructor;
+    const out = new Ctor(src.length + sources.length * size);
+    out.set(src);
+    sources.forEach((s, i) => {
+        for (let k = 0; k < size; k++)
+            out[(accessor.getCount() + i) * size + k] = overridePos ? overridePos[i][k] : src[s * size + k];
+    });
+    return out;
+}
+function writeInfluences(prim, inf, total) {
+    for (const set of [0, 1]) {
+        const ja = prim.getAttribute(`JOINTS_${set}`), wa = prim.getAttribute(`WEIGHTS_${set}`);
+        if (!ja || !wa)
+            continue;
+        const JC = ja.getArray().constructor;
+        const WC = wa.getArray().constructor;
+        const jarr = new JC(total * 4), warr = new WC(total * 4);
+        const normalizedInt = !(warr instanceof Float32Array);
+        const scale = warr instanceof Uint8Array ? 255 : warr instanceof Uint16Array ? 65535 : 1;
+        for (let v = 0; v < total; v++)
+            for (let k = 0; k < 4; k++) {
+                const j = inf.joints[v * 8 + set * 4 + k], w = inf.weights[v * 8 + set * 4 + k];
+                jarr[v * 4 + k] = j >= 0 && w > 0 ? j : 0;
+                warr[v * 4 + k] = j >= 0 && w > 0 ? (normalizedInt ? Math.round(w * scale) : w) : 0;
+            }
+        setAccessorArray(prim, `JOINTS_${set}`, ja, jarr);
+        setAccessorArray(prim, `WEIGHTS_${set}`, wa, warr);
+    }
+}
+function limbSegments(node) {
+    const skin = node.getSkin();
+    const ibm = skin?.getInverseBindMatrices();
+    if (!skin || !ibm)
+        return null;
+    const at = new Map();
+    skin.listJoints().forEach((joint, i) => {
+        const m = (0, mat4_1.invert4)(ibm.getElement(i, new Array(16).fill(0)));
+        at.set(joint.getName(), [m[12], m[13], m[14]]);
+    });
+    const segs = [[], [], [], []];
+    const chain = (limb, names, tipScale) => {
+        const pts = names.map((name) => at.get(name));
+        for (let i = 0; i + 1 < pts.length; i++)
+            if (pts[i] && pts[i + 1])
+                segs[limb].push([...pts[i], ...pts[i + 1]]);
+        const a = pts[pts.length - 2], b = pts[pts.length - 1];
+        if (a && b && tipScale > 0)
+            segs[limb].push([...b, b[0] + (b[0] - a[0]) * tipScale, b[1] + (b[1] - a[1]) * tipScale, b[2] + (b[2] - a[2]) * tipScale]);
+    };
+    for (const [i, s] of [[0, 'l'], [1, 'r']])
+        chain(i, [`upperarm_${s}`, `lowerarm_${s}`, `hand_${s}`], 0.45);
+    for (const [i, s] of [[2, 'l'], [3, 'r']])
+        chain(i, [`thigh_${s}`, `calf_${s}`, `foot_${s}`, `ball_${s}`], 0);
+    return segs.every((x) => x.length > 0) ? segs : null;
+}
+/** Unit vector from the nearest point of the limb's segments to p. */
+function radial(p, segs) {
+    let best = [0, 0, 0], bestD = Infinity;
+    for (const [ax, ay, az, bx, by, bz] of segs) {
+        const dx = bx - ax, dy = by - ay, dz = bz - az;
+        const len2 = dx * dx + dy * dy + dz * dz;
+        const t = len2 > 0 ? Math.max(0, Math.min(1, ((p[0] - ax) * dx + (p[1] - ay) * dy + (p[2] - az) * dz) / len2)) : 0;
+        const rx = p[0] - (ax + t * dx), ry = p[1] - (ay + t * dy), rz = p[2] - (az + t * dz);
+        const d = Math.hypot(rx, ry, rz);
+        if (d < bestD) {
+            bestD = d;
+            best = d > 0 ? [rx / d, ry / d, rz / d] : [0, 0, 0];
+        }
+    }
+    return best;
+}
+/** Area-weighted vertex normals over welded positions (Meshy's per-copy normals are shredded at seams). */
+function weldedNormals(pos, index, weld, welds) {
+    const acc = new Float64Array(welds * 3);
+    for (let t = 0; t < index.length; t += 3) {
+        const a = index[t], b = index[t + 1], c = index[t + 2];
+        const ux = pos[b * 3] - pos[a * 3], uy = pos[b * 3 + 1] - pos[a * 3 + 1], uz = pos[b * 3 + 2] - pos[a * 3 + 2];
+        const vx = pos[c * 3] - pos[a * 3], vy = pos[c * 3 + 1] - pos[a * 3 + 1], vz = pos[c * 3 + 2] - pos[a * 3 + 2];
+        const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+        for (const v of [a, b, c]) {
+            const w = weld[v];
+            acc[w * 3] += nx;
+            acc[w * 3 + 1] += ny;
+            acc[w * 3 + 2] += nz;
+        }
+    }
+    for (let w = 0; w < welds; w++) {
+        const l = Math.hypot(acc[w * 3], acc[w * 3 + 1], acc[w * 3 + 2]);
+        if (l > 0) {
+            acc[w * 3] /= l;
+            acc[w * 3 + 1] /= l;
+            acc[w * 3 + 2] /= l;
+        }
+    }
+    return acc;
+}
+/** A vertex weighted to both an arm and a leg sides with the limb its surface faces away from: on a thigh, the
+ * normal points away from the thigh bone and TOWARDS the resting hand's bone; on the hand, the reverse. */
+const FACING_MARGIN = 0.35;
+/** Surface distance from a weight-detected bridge within which contact vertices are sided by facing. */
+const FACING_RADIUS_M = 0.08;
+function runPass(state, jointLimb, settings, segs, lumaOf) {
+    const { n, pos, index, inf } = state;
+    const { weld, welds } = weldPositions(pos, n);
+    const surface = { n, pos, weld, welds };
+    const normals = segs ? weldedNormals(pos, index, weld, welds) : null;
+    const label = new Int8Array(n).fill(-1);
+    const vertexSide = new Int8Array(n);
+    for (let v = 0; v < n; v++) {
+        const sums = [0, 0, 0, 0];
+        for (let k = 0; k < 8; k++) {
+            const j = inf.joints[v * 8 + k], w = inf.weights[v * 8 + k];
+            if (j >= 0 && w > 0 && jointLimb[j] >= 0)
+                sums[jointLimb[j]] += w;
+        }
+        let best = -1, bw = 0;
+        sums.forEach((s, l) => { if (s > bw) {
+            bw = s;
+            best = l;
+        } });
+        if (bw >= settings.dominance)
+            label[v] = best;
+        const arm = sums[0] + sums[1], leg = sums[2] + sums[3];
+        vertexSide[v] = arm > leg ? 1 : leg > arm ? 2 : 0;
+    }
+    // Near a bridge, weights do not say which surface a vertex is on: the rigger spread hand weight over the thigh
+    // under the resting hand and thigh weight over the hand. There, a limb-owned vertex sides with the limb whose
+    // bone its surface faces away from (the thigh's normal points away from the thigh bone and towards the hand's
+    // bone; the hand's the other way round). Nothing outside FACING_RADIUS_M of a weight-detected bridge moves.
+    let facingRelabels = 0;
+    const seed = detectBridges(index, weld, pos, label);
+    if (normals && segs && seed.clusters.length > 0) {
+        const adj = new Map();
+        const link = (a, b) => {
+            const wa = weld[a], wb = weld[b];
+            if (wa === wb)
+                return;
+            const l = Math.hypot(pos[a * 3] - pos[b * 3], pos[a * 3 + 1] - pos[b * 3 + 1], pos[a * 3 + 2] - pos[b * 3 + 2]);
+            (adj.get(wa) ?? adj.set(wa, []).get(wa)).push([wb, l]);
+            (adj.get(wb) ?? adj.set(wb, []).get(wb)).push([wa, l]);
+        };
+        for (let t = 0; t < index.length; t += 3) {
+            link(index[t], index[t + 1]);
+            link(index[t + 1], index[t + 2]);
+            link(index[t + 2], index[t]);
+        }
+        const dist = new Map();
+        const queue = [];
+        for (let t = 0; t < seed.cluster.length; t++)
+            if (seed.cluster[t] >= 0)
+                for (let k = 0; k < 3; k++) {
+                    const w = weld[index[t * 3 + k]];
+                    if (!dist.has(w)) {
+                        dist.set(w, 0);
+                        queue.push([0, w]);
+                    }
+                }
+        while (queue.length > 0) {
+            queue.sort((x, y) => y[0] - x[0]);
+            const [dw, w] = queue.pop();
+            if (dw > (dist.get(w) ?? Infinity))
+                continue;
+            for (const [nb, l] of adj.get(w) ?? []) {
+                const nd = dw + l;
+                if (nd > FACING_RADIUS_M || nd >= (dist.get(nb) ?? Infinity))
+                    continue;
+                dist.set(nb, nd);
+                queue.push([nd, nb]);
+            }
+        }
+        // Facing score per welded position (arm-facing minus leg-facing), smoothed over the surface so the side
+        // boundary follows the contact instead of speckling across normal noise.
+        const nearest = (p, limbs, sums) => {
+            const owned = limbs.filter((l) => sums[l] > 0);
+            if (owned.length === 1)
+                return owned[0];
+            if (owned.length === 2)
+                return sums[limbs[0]] >= sums[limbs[1]] ? limbs[0] : limbs[1];
+            let best = limbs[0], bd = Infinity;
+            for (const l of limbs)
+                for (const sg of segs[l]) {
+                    const d = Math.hypot(p[0] - (sg[0] + sg[3]) / 2, p[1] - (sg[1] + sg[4]) / 2, p[2] - (sg[2] + sg[5]) / 2);
+                    if (d < bd) {
+                        bd = d;
+                        best = l;
+                    }
+                }
+            return best;
+        };
+        const score = new Map();
+        const pairOf = new Map();
+        for (let v = 0; v < n; v++) {
+            const w = weld[v];
+            if (!dist.has(w) || score.has(w))
+                continue;
+            const sums = [0, 0, 0, 0];
+            for (let k = 0; k < 8; k++) {
+                const j = inf.joints[v * 8 + k], wt = inf.weights[v * 8 + k];
+                if (j >= 0 && wt > 0 && jointLimb[j] >= 0)
+                    sums[jointLimb[j]] += wt;
+            }
+            if (sums[0] + sums[1] + sums[2] + sums[3] < settings.dominance)
+                continue;
+            const p = [pos[v * 3], pos[v * 3 + 1], pos[v * 3 + 2]];
+            const a = nearest(p, [0, 1], sums), l = nearest(p, [2, 3], sums);
+            const nv = [normals[w * 3], normals[w * 3 + 1], normals[w * 3 + 2]];
+            const ra = radial(p, segs[a]), rl = radial(p, segs[l]);
+            score.set(w, (nv[0] * ra[0] + nv[1] * ra[1] + nv[2] * ra[2]) - (nv[0] * rl[0] + nv[1] * rl[1] + nv[2] * rl[2]));
+            pairOf.set(w, [a, l]);
+        }
+        let smooth = score;
+        for (let it = 0; it < 3; it++) {
+            const nextScore = new Map();
+            for (const [w, sc] of smooth) {
+                let sum = sc, cnt = 1;
+                for (const [nb] of adj.get(w) ?? []) {
+                    const x = smooth.get(nb);
+                    if (x !== undefined) {
+                        sum += x;
+                        cnt++;
+                    }
+                }
+                nextScore.set(w, sum / cnt);
+            }
+            smooth = nextScore;
+        }
+        for (let v = 0; v < n; v++) {
+            const w = weld[v];
+            const sc = smooth.get(w);
+            if (sc === undefined)
+                continue;
+            const [a, l] = pairOf.get(w);
+            const side = sc > FACING_MARGIN ? a : sc < -FACING_MARGIN ? l : -1;
+            if (side < 0 || label[v] === side)
+                continue;
+            facingRelabels++;
+            label[v] = side;
+            vertexSide[v] = isArm(side) ? 1 : 2;
+        }
+    }
+    const triCount = index.length / 3;
+    const baseRoot = componentRoots(index, weld, welds, null);
+    const forced = new Set();
+    const reassigned = [];
+    const reassignedPairs = new Set();
+    let found = detectBridges(index, weld, pos, label);
+    // A piece that only the bridge holds on is not a second body part: it is either debris trapped between
+    // bridge triangles (delete it with them) or part of the limb it hangs from, wrongly weighted to the other
+    // limb (re-assign it to that limb and look again). Each piece is re-assigned at most once.
+    for (let round = 0; round < 6; round++) {
+        let relabelled = false;
+        for (let id = 0; id < found.clusters.length; id++) {
+            const removed = new Uint8Array(triCount);
+            for (let t = 0; t < triCount; t++)
+                if (found.cluster[t] === id)
+                    removed[t] = 1;
+            for (const piece of detachedPieces(index, weld, welds, removed, baseRoot)) {
+                if (piece.length <= DEBRIS_TRIS) {
+                    for (const t of piece)
+                        found.cluster[t] = id;
+                    found.clusters[id].triangles += piece.length;
+                    continue;
+                }
+                const verts = new Set(piece.flatMap((t) => [index[t * 3], index[t * 3 + 1], index[t * 3 + 2]]));
+                if ([...verts].some((v) => forced.has(v)))
+                    continue; // re-assigned once already; the final gate refuses the cluster
+                // Only a hand-sized piece is re-assigned; a whole limb hanging by the bridge is left alone and the gate below
+                // refuses its cluster.
+                const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+                for (const v of verts)
+                    for (let a = 0; a < 3; a++) {
+                        lo[a] = Math.min(lo[a], pos[v * 3 + a]);
+                        hi[a] = Math.max(hi[a], pos[v * 3 + a]);
+                    }
+                if (Math.hypot(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]) > MAX_REASSIGNED_PIECE_M)
+                    continue;
+                let armVotes = 0, legVotes = 0;
+                for (const v of verts) {
+                    if (isArm(label[v]))
+                        armVotes++;
+                    else if (isLeg(label[v]))
+                        legVotes++;
+                }
+                const c = found.clusters[id];
+                const to = legVotes >= armVotes ? LIMBS.indexOf(c.arm) : LIMBS.indexOf(c.leg);
+                for (const v of verts) {
+                    label[v] = to;
+                    vertexSide[v] = isArm(to) ? 1 : 2;
+                    forced.add(v);
+                }
+                reassigned.push(`${piece.length} tris -> ${LIMBS[to]}`);
+                reassignedPairs.add(`${LIMBS.indexOf(c.arm)}|${LIMBS.indexOf(c.leg)}`);
+                relabelled = true;
+            }
+        }
+        if (!relabelled)
+            break;
+        found = detectBridges(index, weld, pos, label);
+    }
+    const { cluster, clusters } = found;
+    for (const c of clusters)
+        if (c.triangles > settings.maxClusterTris)
+            c.refused = `larger than ${settings.maxClusterTris} triangles (deliberate geometry?)`;
+    const result = {
+        clusters, reassigned, bridgeTriangles: clusters.reduce((x, c) => x + c.triangles, 0),
+        removedTriangles: 0, fillTriangles: 0, holes: 0, bowties: 0, reweighted: 0, next: null,
+    };
+    if (result.bridgeTriangles === 0 && forced.size === 0)
+        return result;
+    // Structural gate per cluster, after debris and re-assignment: cutting it must not detach geometry.
+    clusters.forEach((c, id) => {
+        if (c.refused)
+            return;
+        const removed = new Uint8Array(triCount);
+        for (let t = 0; t < triCount; t++)
+            if (cluster[t] === id)
+                removed[t] = 1;
+        if (detachedPieces(index, weld, welds, removed, baseRoot).length > 0)
+            c.refused = 'cutting it would detach a piece of the mesh';
+    });
+    const accepted = new Set(clusters.flatMap((c, i) => (c.refused ? [] : [i])));
+    let plan = null;
+    while (accepted.size > 0 || forced.size > 0) {
+        const pairs = new Set([...accepted].map((id) => `${LIMBS.indexOf(clusters[id].arm)}|${LIMBS.indexOf(clusters[id].leg)}`));
+        for (const p of reassignedPairs)
+            pairs.add(p);
+        const p = planRepair(surface, index, inf, jointLimb, cluster, accepted, settings.cleanseRadius, vertexSide, forced, label, pairs, lumaOf ? (v) => lumaOf(state.uvOrigin[v]) : null);
+        if (p.failedCluster < 0) {
+            plan = p;
+            break;
+        }
+        clusters[p.failedCluster].refused = 'the hole it leaves is not a closed loop';
+        accepted.delete(p.failedCluster);
+    }
+    if (!plan) {
+        result.refusedReason = 'every bridge cluster was refused';
+        return result;
+    }
+    const total = n + plan.dups.length;
+    const P = new Float32Array(total * 3);
+    P.set(pos);
+    plan.dups.forEach((d, i) => P.set(d.pos, (n + i) * 3));
+    const origin = new Int32Array(total), uvOrigin = new Int32Array(total);
+    origin.set(state.origin);
+    uvOrigin.set(state.uvOrigin);
+    plan.dups.forEach((d, i) => { origin[n + i] = state.origin[d.source]; uvOrigin[n + i] = state.uvOrigin[d.uvFrom ?? d.source]; });
+    result.removedTriangles = [...accepted].reduce((x, id) => x + clusters[id].triangles, 0);
+    result.fillTriangles = plan.fillTris;
+    result.holes = plan.holes;
+    result.bowties = plan.dups.filter((d) => d.uvFrom === undefined).length;
+    result.reweighted = plan.reweighted;
+    result.next = { n: total, pos: P, index: plan.tris, inf: plan.inf, origin, uvOrigin };
+    return result;
+}
+function applyState(prim, state, n0) {
+    const extra = Array.from(state.origin.subarray(n0));
+    if (extra.length > 0) {
+        const extraPos = extra.map((_, i) => [state.pos[(n0 + i) * 3], state.pos[(n0 + i) * 3 + 1], state.pos[(n0 + i) * 3 + 2]]);
+        for (const semantic of prim.listSemantics()) {
+            if (/^(JOINTS|WEIGHTS)_/.test(semantic))
+                continue;
+            const accessor = prim.getAttribute(semantic);
+            const from = /^TEXCOORD_/.test(semantic) ? Array.from(state.uvOrigin.subarray(n0)) : extra;
+            setAccessorArray(prim, semantic, accessor, appendElements(accessor, from, semantic === 'POSITION' ? extraPos : undefined));
+        }
+        for (const target of prim.listTargets()) {
+            for (const semantic of target.listSemantics()) {
+                const accessor = target.getAttribute(semantic);
+                target.setAttribute(semantic, accessor.clone().setArray(appendElements(accessor, extra)));
+            }
+        }
+    }
+    writeInfluences(prim, state.inf, state.n);
+    const indices = prim.getIndices();
+    const arr = state.n > 65535 || indices.getArray() instanceof Uint32Array ? state.index : Uint16Array.from(state.index);
+    setAccessorArray(prim, '__indices', indices, arr);
+}
+/** Cuts can expose new arm<->leg triangles (an unowned vertex that sided with the arm next to one that sided
+ * with the leg), so the repair runs in passes until the mesh is clean or a pass stops helping. */
+const MAX_PASSES = 4;
+/**
+ * Detect and (by default) repair arm<->leg bridge geometry on every skinned triangle primitive of `document`.
+ * Joint names must already be helix-humanoid@1 (run after retarget/conform).
+ */
+function repairLimbBridges(document, options = {}) {
+    const mode = options.mode ?? 'repair';
+    const report = { mode, units: [], removedTriangles: 0, fillTriangles: 0, verticesReweighted: 0 };
+    if (mode === 'off')
+        return report;
+    const settings = {
+        dominance: options.limbDominance ?? 0.5,
+        cleanseRadius: options.cleanseRadiusM ?? 0.06,
+        maxClusterTris: options.maxClusterTris ?? 1500,
+    };
+    const strideDeg = options.strideDeg ?? 35;
+    for (const node of document.getRoot().listNodes()) {
+        const mesh = node.getMesh(), skin = node.getSkin();
+        if (!mesh || !skin)
+            continue;
+        const jointLimb = Int8Array.from(skin.listJoints().map((j) => { const l = limbOfJoint(j.getName()); return l === null ? -1 : LIMBS.indexOf(l); }));
+        if (!LIMBS.every((_, i) => jointLimb.includes(i)))
+            continue; // not a full humanoid: nothing to separate
+        const strides = strideMatrices(node, strideDeg);
+        const restMats = (0, posing_1.jointMatrices)(node);
+        const segs = options.facing === false ? null : limbSegments(node);
+        const measure = (st) => {
+            if (!strides)
+                return [0, 0];
+            const rest = skinPositions(st.pos, st.n, st.inf, restMats);
+            return [
+                stretchedAreaPercent(rest, skinPositions(st.pos, st.n, st.inf, strides[0]), st.index),
+                stretchedAreaPercent(rest, skinPositions(st.pos, st.n, st.inf, strides[1]), st.index),
+            ];
+        };
+        const sum = (x) => x[0] + x[1];
+        for (const prim of mesh.listPrimitives()) {
+            const posAcc = prim.getAttribute('POSITION'), idxAcc = prim.getIndices();
+            if (prim.getMode() !== 4 || !posAcc || !idxAcc || !prim.getAttribute('JOINTS_0'))
+                continue;
+            const n0 = posAcc.getCount();
+            const start = {
+                n: n0, pos: Float32Array.from(posAcc.getArray()), index: Uint32Array.from(idxAcc.getArray()),
+                inf: (0, posing_1.readInfluences)(prim, n0), origin: Int32Array.from({ length: n0 }, (_, i) => i),
+                uvOrigin: Int32Array.from({ length: n0 }, (_, i) => i),
+            };
+            const uv = prim.getAttribute('TEXCOORD_0')?.getArray() ?? null;
+            const sample = uv ? options.sampleLuma?.(prim) ?? null : null;
+            const lumaOf = sample && uv ? (v) => sample(uv[v * 2], uv[v * 2 + 1]) : null;
+            const before = measure(start);
+            const unit = {
+                mesh: mesh.getName() || node.getName(), triangles: start.index.length / 3, bridgeTriangles: 0, clusters: [],
+                removedTriangles: 0, fillTriangles: 0, holesClosed: 0, bowtiesSplit: 0, verticesReweighted: 0, reassignedPieces: [],
+                stretchBefore: before.map(round2), stretchAfter: null, outcome: 'clean', passes: 0,
+            };
+            report.units.push(unit);
+            let state = start, current = before;
+            for (let pass = 0; pass < MAX_PASSES; pass++) {
+                const r = runPass(state, jointLimb, settings, segs, lumaOf);
+                if (pass === 0) {
+                    unit.bridgeTriangles = r.bridgeTriangles;
+                    unit.clusters = r.clusters;
+                }
+                unit.reassignedPieces.push(...r.reassigned);
+                if (!r.next) {
+                    if (pass === 0 && r.refusedReason) {
+                        unit.outcome = 'refused';
+                        unit.reason = r.refusedReason;
+                    }
+                    break;
+                }
+                const after = measure(r.next);
+                if (strides !== null && !(sum(after) < sum(current))) {
+                    if (pass === 0) {
+                        unit.outcome = 'no-improvement';
+                        unit.reason = 'the stride stretch did not fall';
+                        unit.stretchAfter = after.map(round2);
+                    }
+                    break;
+                }
+                unit.removedTriangles += r.removedTriangles;
+                unit.fillTriangles += r.fillTriangles;
+                unit.holesClosed += r.holes;
+                unit.bowtiesSplit += r.bowties;
+                unit.verticesReweighted += r.reweighted;
+                unit.passes = pass + 1;
+                state = r.next;
+                current = after;
+            }
+            if (state === start)
+                continue;
+            unit.stretchAfter = current.map(round2);
+            // Final gate against the source: lower in the sum of both strides, higher in neither.
+            if (strides !== null && !(sum(current) < sum(before) && current[0] <= before[0] + 1e-9 && current[1] <= before[1] + 1e-9)) {
+                unit.outcome = 'no-improvement';
+                unit.reason = 'the stride stretch did not fall in both strides';
+                continue;
+            }
+            report.removedTriangles += unit.removedTriangles;
+            report.fillTriangles += unit.fillTriangles;
+            report.verticesReweighted += unit.verticesReweighted;
+            if (mode === 'report') {
+                unit.outcome = 'would-repair';
+                continue;
+            }
+            applyState(prim, state, n0);
+            unit.outcome = 'repaired';
+        }
+    }
+    return report;
+}
+/** Decodes every base-colour texture once (sharp) and returns a luminance sampler factory for `sampleLuma`. */
+async function baseColorLumaSamplers(document) {
+    const sharp = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
+    const decoded = new Map();
+    for (const material of document.getRoot().listMaterials()) {
+        const texture = material.getBaseColorTexture();
+        if (!texture || decoded.has(texture))
+            continue;
+        const image = texture.getImage();
+        try {
+            const raw = image ? await sharp(Buffer.from(image)).ensureAlpha().raw().toBuffer({ resolveWithObject: true }) : null;
+            decoded.set(texture, raw ? { data: raw.data, width: raw.info.width, height: raw.info.height } : null);
+        }
+        catch {
+            decoded.set(texture, null);
+        } // KTX2 or anything sharp cannot read: fall back to the nearest-centre texel
+    }
+    return (prim) => {
+        const img = decoded.get(prim.getMaterial()?.getBaseColorTexture() ?? null) ?? null;
+        if (!img)
+            return null;
+        return (u, v) => {
+            const x = Math.min(img.width - 1, Math.max(0, Math.floor((u - Math.floor(u)) * img.width)));
+            const y = Math.min(img.height - 1, Math.max(0, Math.floor((v - Math.floor(v)) * img.height)));
+            const o = (y * img.width + x) * 4;
+            return 0.2126 * img.data[o] + 0.7152 * img.data[o + 1] + 0.0722 * img.data[o + 2];
+        };
+    };
+}
+const round2 = (x) => Math.round(x * 100) / 100;
+/** One log line per unit that had anything to say. */
+function describeLimbBridgeReport(report) {
+    const lines = [];
+    for (const u of report.units) {
+        if (u.bridgeTriangles === 0 && u.reassignedPieces.length === 0)
+            continue;
+        const clusters = u.clusters.map((c) => `${c.arm}|${c.leg} ${c.triangles}${c.refused ? ` refused: ${c.refused}` : ''}`).join('; ');
+        const what = u.outcome === 'repaired' || u.outcome === 'would-repair'
+            ? `${u.outcome === 'repaired' ? 'cut' : 'would cut'} ${u.removedTriangles} tris, closed ${u.holesClosed} hole(s) with ${u.fillTriangles} tris, split ${u.bowtiesSplit} bow-tie vert(s), reweighted ${u.verticesReweighted} vert(s)${u.reassignedPieces.length > 0 ? `, re-assigned ${u.reassignedPieces.join(', ')}` : ''}`
+            : `${u.outcome}${u.reason ? ` (${u.reason})` : ''}`;
+        const stretch = `stride stretch ${u.stretchBefore.join('/')}%${u.stretchAfter ? ` -> ${u.stretchAfter.join('/')}%` : ''}${u.passes > 1 ? ` (${u.passes} passes)` : ''}`;
+        lines.push(`limb bridges: ${u.mesh}: ${u.bridgeTriangles} arm<->leg tris in ${u.clusters.length} cluster(s) [${clusters}] — ${what}; ${stretch}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=limbBridge.js.map