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

package/dist/character/stages/poseFit/offsetField.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weldByPosition = weldByPosition;
+exports.buildGroupGraph = buildGroupGraph;
+exports.sweepsForRadius = sweepsForRadius;
+exports.smoothWithObstacles = smoothWithObstacles;
+exports.capMagnitudes = capMagnitudes;
+exports.distanceToBoundary = distanceToBoundary;
+exports.hemBandCaps = hemBandCaps;
+const math_1 = require("./math");
+/** Groups vertices whose rest positions coincide to within `quantum` metres (default 1µm — far below any
+ *  modelled feature, far above float32 round-off on character-scale coordinates). */
+function weldByPosition(positions, quantum = 1e-6) {
+    const count = positions.length / 3;
+    const groupOf = new Int32Array(count);
+    const map = new Map();
+    const reps = [];
+    for (let i = 0; i < count; i++) {
+        const key = `${Math.round(positions[i * 3] / quantum)},${Math.round(positions[i * 3 + 1] / quantum)},${Math.round(positions[i * 3 + 2] / quantum)}`;
+        let g = map.get(key);
+        if (g === undefined) {
+            g = reps.length / 3;
+            map.set(key, g);
+            reps.push(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]);
+        }
+        groupOf[i] = g;
+    }
+    return { groupOf, groupCount: reps.length / 3, groupPos: Float64Array.from(reps) };
+}
+/** Builds the welded edge graph from triangles given as group ids (3 per triangle). An edge used by exactly
+ *  one triangle is a boundary edge; non-manifold edges (3+ triangles) are treated as interior. */
+function buildGroupGraph(triangleGroups, groupPos, groupCount) {
+    const edgeUse = new Map();
+    const key = (a, b) => (a < b ? a * groupCount + b : b * groupCount + a);
+    for (let t = 0; t < triangleGroups.length; t += 3) {
+        const a = triangleGroups[t], b = triangleGroups[t + 1], c = triangleGroups[t + 2];
+        for (const [u, v] of [[a, b], [b, c], [c, a]]) {
+            if (u === v)
+                continue;
+            const k = key(u, v);
+            edgeUse.set(k, (edgeUse.get(k) ?? 0) + 1);
+        }
+    }
+    const degree = new Int32Array(groupCount);
+    const boundary = new Uint8Array(groupCount);
+    let totalLen = 0;
+    for (const [k, uses] of edgeUse) {
+        const u = Math.floor(k / groupCount), v = k % groupCount;
+        degree[u]++;
+        degree[v]++;
+        if (uses === 1) {
+            boundary[u] = 1;
+            boundary[v] = 1;
+        }
+        totalLen += Math.hypot(groupPos[u * 3] - groupPos[v * 3], groupPos[u * 3 + 1] - groupPos[v * 3 + 1], groupPos[u * 3 + 2] - groupPos[v * 3 + 2]);
+    }
+    const offsets = new Int32Array(groupCount + 1);
+    for (let g = 0; g < groupCount; g++)
+        offsets[g + 1] = offsets[g] + degree[g];
+    const neighbors = new Int32Array(offsets[groupCount]);
+    const weights = new Float64Array(offsets[groupCount]);
+    const fill = offsets.slice(0, groupCount);
+    const meanEdgeLength = edgeUse.size > 0 ? totalLen / edgeUse.size : 0;
+    const floor = Math.max(meanEdgeLength * 1e-3, 1e-7);
+    for (const k of edgeUse.keys()) {
+        const u = Math.floor(k / groupCount), v = k % groupCount;
+        const l = Math.max(floor, Math.hypot(groupPos[u * 3] - groupPos[v * 3], groupPos[u * 3 + 1] - groupPos[v * 3 + 1], groupPos[u * 3 + 2] - groupPos[v * 3 + 2]));
+        neighbors[fill[u]] = v;
+        weights[fill[u]] = 1 / l;
+        fill[u]++;
+        neighbors[fill[v]] = u;
+        weights[fill[v]] = 1 / l;
+        fill[v]++;
+    }
+    const nearBoundary = Uint8Array.from(boundary);
+    for (let g = 0; g < groupCount; g++) {
+        if (boundary[g])
+            continue;
+        for (let e = offsets[g]; e < offsets[g + 1]; e++)
+            if (boundary[neighbors[e]]) {
+                nearBoundary[g] = 1;
+                break;
+            }
+    }
+    return { offsets, neighbors, weights, boundary, nearBoundary, meanEdgeLength };
+}
+/**
+ * How many smoothing sweeps give a falloff of roughly `radiusMeters` on a mesh with this edge length.
+ * Explicit Laplacian diffusion spreads a spike over ~√k edge rings after k sweeps, so k ≈ (radius / edge)².
+ * Deriving k from a physical radius (instead of a fixed sweep count) keeps the falloff the same size in
+ * centimetres on a dense LOD0 and a coarse LOD2 — a fixed count would make LOD2's bumps 3-4× wider.
+ */
+function sweepsForRadius(radiusMeters, meanEdgeLength, min = 1, max = 60) {
+    if (!(meanEdgeLength > 0) || !(radiusMeters > 0))
+        return 0;
+    return Math.max(min, Math.min(max, Math.round((radiusMeters / meanEdgeLength) ** 2)));
+}
+/**
+ * THE SMOOTHING — an obstacle-constrained membrane, not plain smoothing.
+ *
+ * Input: `offsets` (3 per group), the raw per-group displacement each vertex needs on its own, and the
+ * half-space requirements that produced it. Each sweep does two things:
+ *
+ *   1. Jacobi Laplacian step: x ← (1-α)·x + α·(Σ wᵢⱼ xⱼ / Σ wᵢⱼ). Spikes spread to their neighbours and
+ *      shrink; unconstrained vertices next to a pushed one start moving with it.
+ *   2. Obstacle projection: every group that carries requirements is projected back onto them, so no
+ *      smoothing sweep can ever leave a vertex short of the clearance it was asked for.
+ *
+ * The fixed point is the smoothest field that still satisfies every requirement — a "tent" draped over the
+ * required pushes instead of a bed of nails. That is what keeps silhouettes intact: a lone chord that has to
+ * move 4mm pulls its neighbourhood out in a smooth bump that fades over `radius`, instead of creating a
+ * 4mm dimple-in-reverse that reads as a lump in motion, and a whole region that needs clearance moves as a
+ * sheet. Hem-specific behaviour (so a cuff or waistband is not flared outward) is applied by the caller as a
+ * lower magnitude cap on boundary groups — see `capMagnitudes` and the stage's `hemMaxPushMm`.
+ */
+function smoothWithObstacles(offsets, requirements, graph, sweeps, alpha = 0.5) {
+    const G = graph.boundary.length;
+    let cur = offsets;
+    let next = new Float64Array(offsets.length);
+    const tmp = [0, 0, 0];
+    for (let s = 0; s < sweeps; s++) {
+        for (let g = 0; g < G; g++) {
+            let wsum = 0, sx = 0, sy = 0, sz = 0;
+            for (let e = graph.offsets[g]; e < graph.offsets[g + 1]; e++) {
+                const n = graph.neighbors[e], w = graph.weights[e];
+                wsum += w;
+                sx += w * cur[n * 3];
+                sy += w * cur[n * 3 + 1];
+                sz += w * cur[n * 3 + 2];
+            }
+            if (wsum > 0) {
+                tmp[0] = (1 - alpha) * cur[g * 3] + alpha * (sx / wsum);
+                tmp[1] = (1 - alpha) * cur[g * 3 + 1] + alpha * (sy / wsum);
+                tmp[2] = (1 - alpha) * cur[g * 3 + 2] + alpha * (sz / wsum);
+            }
+            else {
+                tmp[0] = cur[g * 3];
+                tmp[1] = cur[g * 3 + 1];
+                tmp[2] = cur[g * 3 + 2];
+            }
+            const req = requirements[g];
+            if (req && req.length > 0)
+                (0, math_1.projectOntoHalfSpaces)(tmp, req);
+            next[g * 3] = tmp[0];
+            next[g * 3 + 1] = tmp[1];
+            next[g * 3 + 2] = tmp[2];
+        }
+        const swap = cur;
+        cur = next;
+        next = swap;
+    }
+    if (cur !== offsets)
+        offsets.set(cur);
+}
+/** Scales every group's TOTAL displacement (`base` + `offsets`) down to at most `caps[g]` metres, writing the
+ *  capped increment back into `offsets`. Returns how many groups were capped. */
+function capMagnitudes(offsets, base, caps) {
+    let capped = 0;
+    for (let g = 0; g < caps.length; g++) {
+        const tx = base[g * 3] + offsets[g * 3], ty = base[g * 3 + 1] + offsets[g * 3 + 1], tz = base[g * 3 + 2] + offsets[g * 3 + 2];
+        const m = Math.hypot(tx, ty, tz);
+        const cap = caps[g];
+        if (m > cap && m > 0) {
+            const k = cap / m;
+            offsets[g * 3] = tx * k - base[g * 3];
+            offsets[g * 3 + 1] = ty * k - base[g * 3 + 1];
+            offsets[g * 3 + 2] = tz * k - base[g * 3 + 2];
+            capped++;
+        }
+    }
+    return capped;
+}
+/**
+ * Shortest along-surface distance (metres, over welded edges) from every group to the nearest boundary
+ * group — Dijkstra from all boundary groups at once. Infinity for a closed mesh / an island with no hem.
+ * Drives the hem band: a group's push cap ramps from `hemMaxPush` on the hem itself to the full `maxPush`
+ * `hemBand` metres in, so a cuff keeps its edge without a visible step one ring inside it.
+ */
+function distanceToBoundary(graph) {
+    const G = graph.boundary.length;
+    const dist = new Float64Array(G).fill(Infinity);
+    // binary min-heap of [distance, group]
+    const heapD = [], heapG = [];
+    const push = (d, g) => {
+        heapD.push(d);
+        heapG.push(g);
+        let i = heapD.length - 1;
+        while (i > 0) {
+            const p = (i - 1) >> 1;
+            if (heapD[p] <= heapD[i])
+                break;
+            [heapD[p], heapD[i]] = [heapD[i], heapD[p]];
+            [heapG[p], heapG[i]] = [heapG[i], heapG[p]];
+            i = p;
+        }
+    };
+    const pop = () => {
+        const d = heapD[0], g = heapG[0];
+        const ld = heapD.pop(), lg = heapG.pop();
+        if (heapD.length > 0) {
+            heapD[0] = ld;
+            heapG[0] = lg;
+            let i = 0;
+            for (;;) {
+                const l = 2 * i + 1, r = l + 1;
+                let m = i;
+                if (l < heapD.length && heapD[l] < heapD[m])
+                    m = l;
+                if (r < heapD.length && heapD[r] < heapD[m])
+                    m = r;
+                if (m === i)
+                    break;
+                [heapD[m], heapD[i]] = [heapD[i], heapD[m]];
+                [heapG[m], heapG[i]] = [heapG[i], heapG[m]];
+                i = m;
+            }
+        }
+        return [d, g];
+    };
+    for (let g = 0; g < G; g++)
+        if (graph.boundary[g]) {
+            dist[g] = 0;
+            push(0, g);
+        }
+    while (heapD.length > 0) {
+        const [d, g] = pop();
+        if (d > dist[g])
+            continue;
+        for (let e = graph.offsets[g]; e < graph.offsets[g + 1]; e++) {
+            const n = graph.neighbors[e];
+            const nd = d + 1 / graph.weights[e];
+            if (nd < dist[n]) {
+                dist[n] = nd;
+                push(nd, n);
+            }
+        }
+    }
+    return dist;
+}
+/** Per-group push cap: `hemMax` on the hem, ramping linearly to `max` over `band` metres of surface. */
+function hemBandCaps(distToHem, max, hemMax, band) {
+    const caps = new Float64Array(distToHem.length);
+    for (let g = 0; g < caps.length; g++) {
+        const d = distToHem[g];
+        caps[g] = band > 0 && Number.isFinite(d) ? hemMax + (max - hemMax) * Math.min(1, d / band) : (Number.isFinite(d) && d === 0 ? hemMax : max);
+    }
+    return caps;
+}
+//# sourceMappingURL=offsetField.js.map

package/dist/character/stages/poseFit/offsetField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"offsetField.js","sourceRoot":"","sources":["../../../../src/character/stages/poseFit/offsetField.ts"],"names":[],"mappings":"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"}

package/dist/character/stages/poseFit/posing.d.ts

@@ -0,0 +1,52 @@
+import { type Accessor, type Document, type Node, type Primitive } from '@gltf-transform/core';
+export interface PoseDelta {
+    joint: string;
+    axis: readonly [number, number, number];
+    angleDeg: number;
+}
+export declare const FIT_POSES: Readonly<Record<string, readonly PoseDelta[]>>;
+export declare const FIT_POSE_NAMES: string[];
+/**
+ * Runs `fn` with `document` posed as `poseName`, then restores every touched node's exact local TRS — the
+ * document is never left posed, so the same in-memory garment can be measured, fitted and written.
+ */
+export declare function withPose<T>(document: Document, poseName: string, fn: () => T): T;
+/** Dominant-joint region label, exactly as the checker's `regionForJoint`. */
+export declare function regionForJoint(jointName: string): string | null;
+export declare function regionGlobMatcher(globs: readonly string[]): ((region: string | null) => boolean) | null;
+/** Up to 8 influences per vertex (JOINTS_0/WEIGHTS_0 + JOINTS_1/WEIGHTS_1), flattened 8-wide. */
+export interface Influences {
+    count: number;
+    joints: Int32Array;
+    weights: Float64Array;
+    /** Joint index with the largest weight (first wins on ties, as in the checker), or -1. */
+    dominant: Int32Array;
+}
+export declare function readInfluences(prim: Primitive, count: number): Influences;
+/** Per-joint skinning matrices (jointWorld · inverseBind) for a skinned node in the document's CURRENT pose. */
+export declare function jointMatrices(node: Node): number[][];
+/**
+ * Per-vertex blended skinning matrix Σ wᵢ·Mᵢ / Σ wᵢ (16 per vertex, column-major). Linear blend skinning is
+ * affine in the rest position, so posed = B·rest EXACTLY and posed displacement = linearPart(B)·Δrest
+ * EXACTLY — the fit's posed→rest conversion is an exact inverse, not a linearisation. A vertex with no
+ * usable weight falls back to its node's world matrix, as the checker does.
+ */
+export declare function blendMatrices(inf: Influences, mats: readonly number[][], nodeWorld: readonly number[]): Float64Array;
+/**
+ * Posed positions (and unit normals) computed with EXACTLY the checker's floating-point recipe —
+ * Σ wᵢ·(Mᵢ·p) accumulated influence by influence, then × (1/Σw); normals Σ wᵢ·(Mᵢ·n) normalised — so a
+ * vertex sitting right at the 0.5mm threshold, or on a normal-flip boundary, lands on the same side in the
+ * gate as in the checker. (Algebraically identical to `posePositions`, which the fit's own linearisation
+ * uses; the two differ only in the last bits.)
+ */
+export declare function skinLikeChecker(rest: Float64Array, normals: Float64Array | null, inf: Influences, mats: readonly number[][], nodeWorld: readonly number[]): {
+    positions: Float64Array;
+    normals: Float64Array | null;
+};
+/** posed = B · rest for every vertex. */
+export declare function posePositions(rest: Float64Array, blended: Float64Array): Float64Array;
+/** Posed unit normals (linear part of B applied, renormalised — exact for the rigid-dominant blends the body uses). */
+export declare function poseNormals(normals: Float64Array, blended: Float64Array): Float64Array;
+export declare function readVec3(accessor: Accessor): Float64Array;
+/** Every (node, mesh) pair that is skinned — the same set the checker walks. */
+export declare function skinnedMeshNodes(document: Document): Node[];

package/dist/character/stages/poseFit/posing.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIT_POSE_NAMES = exports.FIT_POSES = void 0;
+exports.withPose = withPose;
+exports.regionForJoint = regionForJoint;
+exports.regionGlobMatcher = regionGlobMatcher;
+exports.readInfluences = readInfluences;
+exports.jointMatrices = jointMatrices;
+exports.blendMatrices = blendMatrices;
+exports.skinLikeChecker = skinLikeChecker;
+exports.posePositions = posePositions;
+exports.poseNormals = poseNormals;
+exports.readVec3 = readVec3;
+exports.skinnedMeshNodes = skinnedMeshNodes;
+const core_1 = require("@gltf-transform/core");
+const mat4_1 = require("../../mat4");
+/**
+ * The canonical pose set and the linear-blend skinning the fit stage and its gate both measure in.
+ *
+ * POSES, their application order, the world-space pivot rotation, the joint→region table, the dominant-
+ * joint rule and the skinning arithmetic (`skinLikeChecker`) are copied from
+ * `run/open-alpha-qa/wearables-import/pilot/tools/pokethrough-check.mjs` (the wearables lane's poke-through
+ * checker) so the in-stage gate counts what that checker counts. Every node carrying a joint's name is posed,
+ * not just the first: both shipped base bodies still carry three per-LOD skeleton copies, and posing only the
+ * first left body LOD2/LOD3 at bind pose in every non-idle pose (Female NEO Arcane Heir Gloves read a spurious
+ * 0-violation PASS in arms-raised that way). Found building this stage, 2026-09-28; the checker was fixed to
+ * match the same day (its POSE_DUPLICATE_REASONING).
+ */
+const FLEX_AXIS = [1, 0, 0];
+exports.FIT_POSES = {
+    idle: [],
+    crouch: [
+        { joint: 'thigh_l', axis: FLEX_AXIS, angleDeg: -65 },
+        { joint: 'thigh_r', axis: FLEX_AXIS, angleDeg: -65 },
+        { joint: 'calf_l', axis: FLEX_AXIS, angleDeg: 100 },
+        { joint: 'calf_r', axis: FLEX_AXIS, angleDeg: 100 },
+        { joint: 'spine_01', axis: FLEX_AXIS, angleDeg: -15 },
+    ],
+    'walk-stride': [
+        { joint: 'thigh_l', axis: FLEX_AXIS, angleDeg: 30 },
+        { joint: 'thigh_r', axis: FLEX_AXIS, angleDeg: -30 },
+        { joint: 'calf_l', axis: FLEX_AXIS, angleDeg: -15 },
+        { joint: 'calf_r', axis: FLEX_AXIS, angleDeg: 40 },
+    ],
+    'run-stride': [
+        { joint: 'thigh_l', axis: FLEX_AXIS, angleDeg: 50 },
+        { joint: 'thigh_r', axis: FLEX_AXIS, angleDeg: -55 },
+        { joint: 'calf_l', axis: FLEX_AXIS, angleDeg: -25 },
+        { joint: 'calf_r', axis: FLEX_AXIS, angleDeg: 80 },
+        { joint: 'spine_01', axis: FLEX_AXIS, angleDeg: -20 },
+    ],
+    'arms-raised': [
+        { joint: 'upperarm_l', axis: FLEX_AXIS, angleDeg: -150 },
+        { joint: 'upperarm_r', axis: FLEX_AXIS, angleDeg: -150 },
+    ],
+};
+exports.FIT_POSE_NAMES = Object.keys(exports.FIT_POSES);
+/** Parent-before-child order for the joints any pose touches (a child's pivot uses its parent's posed world). */
+const POSE_APPLICATION_ORDER = ['spine_01', 'thigh_l', 'thigh_r', 'calf_l', 'calf_r', 'upperarm_l', 'upperarm_r'];
+const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+function axisAngleMatrix(axis, angleRad) {
+    const l = Math.hypot(axis[0], axis[1], axis[2]) || 1;
+    const x = axis[0] / l, y = axis[1] / l, z = axis[2] / l;
+    const c = Math.cos(angleRad), s = Math.sin(angleRad), t = 1 - c;
+    return [
+        t * x * x + c, t * x * y + s * z, t * x * z - s * y, 0,
+        t * x * y - s * z, t * y * y + c, t * y * z + s * x, 0,
+        t * x * z + s * y, t * y * z - s * x, t * z * z + c, 0,
+        0, 0, 0, 1,
+    ];
+}
+const translation = (t) => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, t[0], t[1], t[2], 1];
+function parentNode(node) {
+    for (const p of node.listParents())
+        if (p.propertyType === core_1.PropertyType.NODE)
+            return p;
+    return null;
+}
+/**
+ * Runs `fn` with `document` posed as `poseName`, then restores every touched node's exact local TRS — the
+ * document is never left posed, so the same in-memory garment can be measured, fitted and written.
+ */
+function withPose(document, poseName, fn) {
+    const deltas = exports.FIT_POSES[poseName];
+    if (deltas === undefined)
+        throw new Error(`poseFit: unknown pose "${poseName}" (known: ${exports.FIT_POSE_NAMES.join(', ')})`);
+    const byJoint = new Map(deltas.map((d) => [d.joint, d]));
+    const saved = [];
+    const nodes = document.getRoot().listNodes();
+    try {
+        for (const jointName of POSE_APPLICATION_ORDER) {
+            const delta = byJoint.get(jointName);
+            if (!delta)
+                continue;
+            for (const node of nodes) {
+                if (node.getName() !== jointName)
+                    continue;
+                saved.push({ node, t: [...node.getTranslation()], r: [...node.getRotation()], s: [...node.getScale()] });
+                const parent = parentNode(node);
+                const parentWorld = parent ? parent.getWorldMatrix() : IDENTITY;
+                const worldOld = node.getWorldMatrix();
+                const pivot = [worldOld[12], worldOld[13], worldOld[14]];
+                const rot = axisAngleMatrix(delta.axis, (delta.angleDeg * Math.PI) / 180);
+                const pivotRotation = (0, mat4_1.mul4)((0, mat4_1.mul4)(translation(pivot), rot), translation([-pivot[0], -pivot[1], -pivot[2]]));
+                node.setMatrix((0, mat4_1.mul4)((0, mat4_1.invert4)(parentWorld), (0, mat4_1.mul4)(pivotRotation, worldOld)));
+            }
+        }
+        return fn();
+    }
+    finally {
+        for (let i = saved.length - 1; i >= 0; i--) {
+            const { node, t, r, s } = saved[i];
+            node.setTranslation(t).setRotation(r).setScale(s);
+        }
+    }
+}
+// ── body regions (the checker's --hidden-regions scope gate) ──────────────────────────────────────────────
+const JOINT_TO_REGION = {
+    head: 'body_head', neck_01: 'body_neck', neck_02: 'body_neck',
+    spine_01: 'body_torso', spine_02: 'body_torso', spine_03: 'body_torso', spine_04: 'body_torso', spine_05: 'body_torso',
+    pelvis: 'body_hip',
+    clavicle_l: 'body_torso', clavicle_r: 'body_torso',
+    upperarm_l: 'body_upperarm_l', upperarm_twist_01_l: 'body_upperarm_l', upperarm_twist_02_l: 'body_upperarm_l',
+    upperarm_r: 'body_upperarm_r', upperarm_twist_01_r: 'body_upperarm_r', upperarm_twist_02_r: 'body_upperarm_r',
+    lowerarm_l: 'body_forearm_l', lowerarm_twist_01_l: 'body_forearm_l', lowerarm_twist_02_l: 'body_forearm_l',
+    lowerarm_r: 'body_forearm_r', lowerarm_twist_01_r: 'body_forearm_r', lowerarm_twist_02_r: 'body_forearm_r',
+    thigh_l: 'body_thigh_l', thigh_twist_01_l: 'body_thigh_l', thigh_r: 'body_thigh_r', thigh_twist_01_r: 'body_thigh_r',
+    calf_l: 'body_shin_l', calf_twist_01_l: 'body_shin_l', calf_r: 'body_shin_r', calf_twist_01_r: 'body_shin_r',
+    foot_l: 'body_foot_l', ball_l: 'body_foot_l', foot_r: 'body_foot_r', ball_r: 'body_foot_r',
+};
+/** Dominant-joint region label, exactly as the checker's `regionForJoint`. */
+function regionForJoint(jointName) {
+    const direct = JOINT_TO_REGION[jointName];
+    if (direct)
+        return direct;
+    if (/^hand_l$|_l$/.test(jointName) && /(pinky|ring|thumb|middle|index|hand)/.test(jointName))
+        return 'body_hand_l';
+    if (/^hand_r$|_r$/.test(jointName) && /(pinky|ring|thumb|middle|index|hand)/.test(jointName))
+        return 'body_hand_r';
+    return null;
+}
+function regionGlobMatcher(globs) {
+    if (globs.length === 0)
+        return null; // unscoped: every proximate vertex is eligible
+    const res = globs.map((glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`));
+    return (region) => region !== null && res.some((re) => re.test(region));
+}
+function readInfluences(prim, count) {
+    const joints = new Int32Array(count * 8).fill(-1);
+    const weights = new Float64Array(count * 8);
+    const dominant = new Int32Array(count).fill(-1);
+    const sets = [];
+    for (const s of [0, 1]) {
+        const j = prim.getAttribute(`JOINTS_${s}`), w = prim.getAttribute(`WEIGHTS_${s}`);
+        if (j && w)
+            sets.push([j, w]);
+    }
+    const jb = [0, 0, 0, 0], wb = [0, 0, 0, 0];
+    for (let i = 0; i < count; i++) {
+        let best = -1;
+        let slot = 0;
+        for (const [j, w] of sets) {
+            j.getElement(i, jb);
+            w.getElement(i, wb);
+            for (let k = 0; k < 4; k++) {
+                const weight = wb[k];
+                if (weight <= 0) {
+                    slot++;
+                    continue;
+                }
+                joints[i * 8 + slot] = jb[k];
+                weights[i * 8 + slot] = weight;
+                if (weight > best) {
+                    best = weight;
+                    dominant[i] = jb[k];
+                }
+                slot++;
+            }
+        }
+    }
+    return { count, joints, weights, dominant };
+}
+/** Per-joint skinning matrices (jointWorld · inverseBind) for a skinned node in the document's CURRENT pose. */
+function jointMatrices(node) {
+    const skin = node.getSkin();
+    if (!skin)
+        return [];
+    const ibm = skin.getInverseBindMatrices();
+    return skin.listJoints().map((joint, i) => (0, mat4_1.mul4)(joint.getWorldMatrix(), ibm ? ibm.getElement(i, new Array(16).fill(0)) : IDENTITY));
+}
+/**
+ * Per-vertex blended skinning matrix Σ wᵢ·Mᵢ / Σ wᵢ (16 per vertex, column-major). Linear blend skinning is
+ * affine in the rest position, so posed = B·rest EXACTLY and posed displacement = linearPart(B)·Δrest
+ * EXACTLY — the fit's posed→rest conversion is an exact inverse, not a linearisation. A vertex with no
+ * usable weight falls back to its node's world matrix, as the checker does.
+ */
+function blendMatrices(inf, mats, nodeWorld) {
+    const out = new Float64Array(inf.count * 16);
+    for (let i = 0; i < inf.count; i++) {
+        let wsum = 0;
+        const o = i * 16;
+        for (let k = 0; k < 8; k++) {
+            const j = inf.joints[i * 8 + k];
+            if (j < 0)
+                continue;
+            const m = mats[j];
+            if (!m)
+                continue;
+            const w = inf.weights[i * 8 + k];
+            for (let e = 0; e < 16; e++)
+                out[o + e] += w * m[e];
+            wsum += w;
+        }
+        if (wsum > 0) {
+            if (wsum !== 1)
+                for (let e = 0; e < 16; e++)
+                    out[o + e] /= wsum;
+        }
+        else {
+            for (let e = 0; e < 16; e++)
+                out[o + e] = nodeWorld[e];
+        }
+    }
+    return out;
+}
+/**
+ * Posed positions (and unit normals) computed with EXACTLY the checker's floating-point recipe —
+ * Σ wᵢ·(Mᵢ·p) accumulated influence by influence, then × (1/Σw); normals Σ wᵢ·(Mᵢ·n) normalised — so a
+ * vertex sitting right at the 0.5mm threshold, or on a normal-flip boundary, lands on the same side in the
+ * gate as in the checker. (Algebraically identical to `posePositions`, which the fit's own linearisation
+ * uses; the two differ only in the last bits.)
+ */
+function skinLikeChecker(rest, normals, inf, mats, nodeWorld) {
+    const count = rest.length / 3;
+    const positions = new Float64Array(count * 3);
+    const outNormals = normals ? new Float64Array(count * 3) : null;
+    for (let i = 0; i < count; i++) {
+        const px = rest[i * 3], py = rest[i * 3 + 1], pz = rest[i * 3 + 2];
+        let ax = 0, ay = 0, az = 0, nx = 0, ny = 0, nz = 0, wsum = 0;
+        const qx = normals ? normals[i * 3] : 0, qy = normals ? normals[i * 3 + 1] : 0, qz = normals ? normals[i * 3 + 2] : 0;
+        for (let k = 0; k < 8; k++) {
+            const j = inf.joints[i * 8 + k];
+            if (j < 0)
+                continue;
+            const m = mats[j];
+            if (!m)
+                continue;
+            const w = inf.weights[i * 8 + k];
+            ax = ax + (m[0] * px + m[4] * py + m[8] * pz + m[12]) * w;
+            ay = ay + (m[1] * px + m[5] * py + m[9] * pz + m[13]) * w;
+            az = az + (m[2] * px + m[6] * py + m[10] * pz + m[14]) * w;
+            if (normals) {
+                nx = nx + (m[0] * qx + m[4] * qy + m[8] * qz) * w;
+                ny = ny + (m[1] * qx + m[5] * qy + m[9] * qz) * w;
+                nz = nz + (m[2] * qx + m[6] * qy + m[10] * qz) * w;
+            }
+            wsum += w;
+        }
+        if (wsum > 0) {
+            const inv = 1 / wsum;
+            positions[i * 3] = ax * inv;
+            positions[i * 3 + 1] = ay * inv;
+            positions[i * 3 + 2] = az * inv;
+        }
+        else {
+            const m = nodeWorld;
+            positions[i * 3] = m[0] * px + m[4] * py + m[8] * pz + m[12];
+            positions[i * 3 + 1] = m[1] * px + m[5] * py + m[9] * pz + m[13];
+            positions[i * 3 + 2] = m[2] * px + m[6] * py + m[10] * pz + m[14];
+            if (normals) {
+                const m2 = nodeWorld;
+                nx = m2[0] * qx + m2[4] * qy + m2[8] * qz;
+                ny = m2[1] * qx + m2[5] * qy + m2[9] * qz;
+                nz = m2[2] * qx + m2[6] * qy + m2[10] * qz;
+            }
+        }
+        if (outNormals) {
+            const l = Math.hypot(nx, ny, nz) || 1;
+            outNormals[i * 3] = nx / l;
+            outNormals[i * 3 + 1] = ny / l;
+            outNormals[i * 3 + 2] = nz / l;
+        }
+    }
+    return { positions, normals: outNormals };
+}
+/** posed = B · rest for every vertex. */
+function posePositions(rest, blended) {
+    const count = rest.length / 3;
+    const out = new Float64Array(count * 3);
+    for (let i = 0; i < count; i++) {
+        const m = blended.subarray(i * 16, i * 16 + 16);
+        const p = (0, mat4_1.transformPoint)(m, [rest[i * 3], rest[i * 3 + 1], rest[i * 3 + 2]]);
+        out[i * 3] = p[0];
+        out[i * 3 + 1] = p[1];
+        out[i * 3 + 2] = p[2];
+    }
+    return out;
+}
+/** Posed unit normals (linear part of B applied, renormalised — exact for the rigid-dominant blends the body uses). */
+function poseNormals(normals, blended) {
+    const count = normals.length / 3;
+    const out = new Float64Array(count * 3);
+    for (let i = 0; i < count; i++) {
+        const m = blended.subarray(i * 16, i * 16 + 16);
+        const x = normals[i * 3], y = normals[i * 3 + 1], z = normals[i * 3 + 2];
+        const nx = m[0] * x + m[4] * y + m[8] * z, ny = m[1] * x + m[5] * y + m[9] * z, nz = m[2] * x + m[6] * y + m[10] * z;
+        const l = Math.hypot(nx, ny, nz) || 1;
+        out[i * 3] = nx / l;
+        out[i * 3 + 1] = ny / l;
+        out[i * 3 + 2] = nz / l;
+    }
+    return out;
+}
+function readVec3(accessor) {
+    const count = accessor.getCount();
+    const out = new Float64Array(count * 3);
+    const b = [0, 0, 0];
+    for (let i = 0; i < count; i++) {
+        accessor.getElement(i, b);
+        out[i * 3] = b[0];
+        out[i * 3 + 1] = b[1];
+        out[i * 3 + 2] = b[2];
+    }
+    return out;
+}
+/** Every (node, mesh) pair that is skinned — the same set the checker walks. */
+function skinnedMeshNodes(document) {
+    return document.getRoot().listNodes().filter((node) => node.getMesh() !== null && node.getSkin() !== null);
+}
+//# sourceMappingURL=posing.js.map