@bitmagic/cli 0.1.65 → 0.1.66-dev.10

package/assets/metahuman/tools/metahuman/e2e/probes/bone-displacement.js

@@ -0,0 +1,26 @@
+(() => {
+  const model = window.__lab.actor.getModel();
+  let body = null; const outfit = [];
+  model.traverse((o) => {
+    if (o.isSkinnedMesh && /Body_Baked/.test(o.material.name)) body = o;
+    if (o.isSkinnedMesh && /bodyShapeD/.test(o.material.name)) outfit.push(o);
+  });
+  outfit.forEach((m) => { m.visible = false; });
+  window.__lab.setLife(false);
+  const M4 = body.matrixWorld.constructor, V = body.position.constructor, Q = body.quaternion.constructor;
+  model.updateMatrixWorld(true);
+  const modelInv = new M4().copy(model.matrixWorld).invert();
+  const sk = body.skeleton; const res = [];
+  const bindM = new M4(), curM = new M4(), p = new V(), q = new Q(), sc = new V(), p2 = new V(), q2 = new Q();
+  sk.bones.forEach((b, i) => {
+    bindM.copy(sk.boneInverses[i]).invert().decompose(p, q, sc);
+    curM.copy(modelInv).multiply(b.matrixWorld).decompose(p2, q2, sc);
+    const rot = Math.round(2 * Math.acos(Math.min(1, Math.abs(q.dot(q2)))) * 180 / Math.PI);
+    res.push({ bone: b.name, dPos: +p.distanceTo(p2).toFixed(3), dRot: rot, parent: b.parent && b.parent.name });
+  });
+  const fmt = (r) => r.bone + ' ' + r.dPos + 'm ' + r.dRot + 'deg (parent ' + r.parent + ')';
+  return {
+    topByPosition: [...res].sort((a, b) => b.dPos - a.dPos).slice(0, 12).map(fmt),
+    topByRotation: [...res].sort((a, b) => b.dRot - a.dRot).slice(0, 16).map(fmt),
+  };
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/clip-shoulder.js

@@ -0,0 +1,41 @@
+// Raw clip analysis: for each loaded locomotion clip, the mean local rotation of key bones and how far
+// the pose swings around that mean. Compares Walking/Running to Idle so a baked-in offset (asset) is
+// distinguishable from motion (animation).
+(() => {
+  const plRaw = window.__lab.playerLoader; const pl = typeof plRaw === 'function' ? plRaw() : plRaw;
+  const ac = pl.getAnimationController();
+  const players = [ac.getTrackAMixamoPlayer(), ac.getTrackBMixamoPlayer()].filter(Boolean);
+  const mp = players[0];
+  const clips = new Map();
+  for (const p of players) {
+    const mixer = p.mixer || p._mixer; const actions = (mixer && mixer._actions) || [];
+    for (const a of actions) { const c = a.getClip ? a.getClip() : a._clip; if (c && !clips.has(c.name)) clips.set(c.name, c); }
+    const cur = p.currentAction && (p.currentAction.getClip ? p.currentAction.getClip() : p.currentAction._clip); if (cur && !clips.has(cur.name)) clips.set(cur.name, cur);
+    for (const k of Object.keys(p)) { const v = p[k]; if (v && typeof v === 'object' && v.isAnimationClip && !clips.has(v.name)) clips.set(v.name, v); if (v instanceof Map) for (const c of v.values()) if (c && c.isAnimationClip && !clips.has(c.name)) clips.set(c.name, c); }
+  }
+  const Q = window.__lab.engine().camera.quaternion.constructor; const E = window.__lab.engine().camera.rotation.constructor;
+  const bones = ['LeftShoulder', 'RightShoulder', 'Spine', 'Spine1', 'Spine2', 'Neck', 'Hips', 'LeftUpLeg', 'LeftLeg'];
+  const trackFor = (clip, bone, kind) => clip.tracks.find((t) => t.name.replace(/^mixamorig\d*/, '').replace(/^\./, '') === `${bone}.${kind}`);
+  const meanQuat = (t) => { const n = t.values.length / 4; const acc = [0, 0, 0, 0]; const q0 = [t.values[0], t.values[1], t.values[2], t.values[3]]; for (let i = 0; i < n; i++) { let q = [t.values[i * 4], t.values[i * 4 + 1], t.values[i * 4 + 2], t.values[i * 4 + 3]]; const d = q[0] * q0[0] + q[1] * q0[1] + q[2] * q0[2] + q[3] * q0[3]; if (d < 0) q = q.map((x) => -x); for (let k = 0; k < 4; k++) acc[k] += q[k]; } const l = Math.hypot(...acc); return new Q(acc[0] / l, acc[1] / l, acc[2] / l, acc[3] / l); };
+  const angleBetween = (a, b) => { const d = Math.abs(a.dot(b)); return 2 * Math.acos(Math.min(1, d)) * 180 / Math.PI; };
+  const eulerDeg = (q) => { const e = new E().setFromQuaternion(q, 'XYZ'); return [e.x, e.y, e.z].map((v) => +(v * 180 / Math.PI).toFixed(1)); };
+  const out = { clips: [...clips.keys()], rows: [] };
+  const idle = clips.get('Idle');
+  for (const [name, clip] of clips) {
+    const row = { clip: name, duration: +clip.duration.toFixed(2), tracks: clip.tracks.length, bones: {} };
+    for (const b of bones) {
+      const t = trackFor(clip, b, 'quaternion'); if (!t) continue;
+      const m = meanQuat(t); const n = t.values.length / 4; let maxDev = 0;
+      for (let i = 0; i < n; i++) { const q = new Q(t.values[i * 4], t.values[i * 4 + 1], t.values[i * 4 + 2], t.values[i * 4 + 3]); maxDev = Math.max(maxDev, angleBetween(q, m)); }
+      const entry = { meanEulerXYZ: eulerDeg(m), swingDeg: +maxDev.toFixed(1) };
+      if (idle && idle !== clip) { const ti = trackFor(idle, b, 'quaternion'); if (ti) entry.offsetFromIdleDeg = +angleBetween(m, meanQuat(ti)).toFixed(1); }
+      row.bones[b] = entry;
+    }
+    const hp = trackFor(clip, 'Hips', 'position');
+    if (hp) { const n = hp.values.length / 3; let sy = 0, mn = 1e9, mx = -1e9; for (let i = 0; i < n; i++) { const y = hp.values[i * 3 + 1]; sy += y; mn = Math.min(mn, y); mx = Math.max(mx, y); } row.hipsY = { mean: +(sy / n).toFixed(3), min: +mn.toFixed(3), max: +mx.toFixed(3) }; }
+    out.rows.push(row);
+  }
+  out.mpKeys = Object.keys(mp).filter((k) => /url|src|source|asset|pack|clip|name/i.test(k)).slice(0, 12);
+  out.acKeys = Object.keys(ac).filter((k) => /url|src|source|asset|pack|clip/i.test(k)).slice(0, 12);
+  return out;
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/grafted-bones.js

@@ -0,0 +1,11 @@
+(() => {
+  const a = window.__lab.actor; const model = a.getModel();
+  const names = ['thigh_correctiveRoot_r', 'lowerarm_correctiveRoot_l', 'calf_correctiveRoot_r', 'upperarm_twistCor_01_l', 'upperarm_bicep_l', 'ankle_bck_r', 'upperarm_correctiveRoot_l', 'thigh_l', 'lowerarm_l'];
+  const out = {};
+  for (const n of names) {
+    const b = a.getBone(n); let found = null; model.traverse((o) => { if (!found && o.name === n) found = o; });
+    out[n] = { viaActor: !!b, inModel: !!found, isBone: found ? !!found.isBone : null, type: found ? found.type : null, parent: found && found.parent ? found.parent.name : null };
+  }
+  let bones = 0, nonBoneNamedJoints = 0; model.traverse((o) => { if (o.isBone) bones++; else if (/_[lr]$/.test(o.name) && !o.isMesh) nonBoneNamedJoints++; });
+  return { out, bonesInModel: bones, nonBoneJointLikeNodes: nonBoneNamedJoints };
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/helper-follow-descent.js

@@ -0,0 +1,38 @@
+(async () => {
+  const model = window.__lab.actor.getModel(); const meshes = [];
+  model.traverse((o) => { if (o.isSkinnedMesh && /Shirt|Short_|Body_Baked/.test(o.material.name)) meshes.push(o); });
+  window.__lab.setLife(false);
+  const V = meshes[0].position.constructor;
+  const torn = (mesh) => {
+    const g = mesh.geometry, pos = g.attributes.position, idx = g.index; const v = new V();
+    const sk = new Float32Array(pos.count * 3);
+    for (let i = 0; i < pos.count; i++) { v.set(pos.getX(i), pos.getY(i), pos.getZ(i)); mesh.applyBoneTransform(i, v); sk[i * 3] = v.x; sk[i * 3 + 1] = v.y; sk[i * 3 + 2] = v.z; }
+    let n = 0; const a = new V(), b = new V(), a2 = new V(), b2 = new V();
+    for (let t = 0; t < idx.count; t += 3) for (let e = 0; e < 3; e++) {
+      const i0 = idx.getX(t + e), i1 = idx.getX(t + (e + 1) % 3);
+      a.set(pos.getX(i0), pos.getY(i0), pos.getZ(i0)); b.set(pos.getX(i1), pos.getY(i1), pos.getZ(i1));
+      a2.set(sk[i0 * 3], sk[i0 * 3 + 1], sk[i0 * 3 + 2]); b2.set(sk[i1 * 3], sk[i1 * 3 + 1], sk[i1 * 3 + 2]);
+      const l0 = a.distanceTo(b); if (l0 > 1e-6 && a2.distanceTo(b2) / l0 > 3) n++;
+    }
+    return n;
+  };
+  const frames = (n) => new Promise((r) => { let k = 0; const step = () => (++k >= n ? r() : requestAnimationFrame(step)); requestAnimationFrame(step); });
+  const score = async (cfg) => { window.__lab.setHelperFollow(cfg); await frames(4); return meshes.reduce((s, m) => s + torn(m), 0); };
+  const groups = ['shoulder', 'thigh', 'elbow', 'knee', 'twistCor', 'muscle', 'clavicle', 'lat', 'wrist', 'ankle', 'finger'];
+  const cfg = Object.fromEntries(groups.map((g) => [g, 1]));
+  const log = [];
+  let best = await score(cfg); log.push('rigid FK everywhere: ' + best);
+  for (let pass = 0; pass < 2; pass++) {
+    for (const g of groups) {
+      let bestVal = cfg[g];
+      for (const val of [0, 0.5, 1]) {
+        if (val === cfg[g]) continue;
+        const trial = { ...cfg, [g]: val }; const sc = await score(trial);
+        if (sc < best) { best = sc; bestVal = val; }
+      }
+      if (bestVal !== cfg[g]) { cfg[g] = bestVal; log.push(`pass ${pass} ${g} → ${bestVal}: ${best}`); }
+    }
+  }
+  await score(cfg);
+  return { best, cfg, log, perMesh: meshes.map((m) => m.name + ':' + torn(m)) };
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/helper-follow-sweep.js

@@ -0,0 +1,31 @@
+(async () => {
+  const model = window.__lab.actor.getModel(); let shirt = null, shorts = null;
+  model.traverse((o) => { if (o.isSkinnedMesh && /Shirt/.test(o.material.name)) shirt = o; if (o.isSkinnedMesh && /Short_/.test(o.material.name)) shorts = o; });
+  window.__lab.setLife(false);
+  const V = shirt.position.constructor;
+  const stretched = (mesh) => {
+    const g = mesh.geometry, pos = g.attributes.position, idx = g.index; const v = new V();
+    const sk = new Float32Array(pos.count * 3);
+    for (let i = 0; i < pos.count; i++) { v.set(pos.getX(i), pos.getY(i), pos.getZ(i)); mesh.applyBoneTransform(i, v); sk[i * 3] = v.x; sk[i * 3 + 1] = v.y; sk[i * 3 + 2] = v.z; }
+    let n = 0, worst = 0; const a = new V(), b = new V(), a2 = new V(), b2 = new V();
+    for (let t = 0; t < idx.count; t += 3) for (let e = 0; e < 3; e++) {
+      const i0 = idx.getX(t + e), i1 = idx.getX(t + (e + 1) % 3);
+      a.set(pos.getX(i0), pos.getY(i0), pos.getZ(i0)); b.set(pos.getX(i1), pos.getY(i1), pos.getZ(i1));
+      a2.set(sk[i0 * 3], sk[i0 * 3 + 1], sk[i0 * 3 + 2]); b2.set(sk[i1 * 3], sk[i1 * 3 + 1], sk[i1 * 3 + 2]);
+      const l0 = a.distanceTo(b), l1 = a2.distanceTo(b2); if (l0 > 1e-6) { const r = l1 / l0; if (r > 3) n++; if (r > worst) worst = r; }
+    }
+    return { over3x: n, worst: +worst.toFixed(1) };
+  };
+  const frames = (n) => new Promise((r) => { let k = 0; const step = () => (++k >= n ? r() : requestAnimationFrame(step)); requestAnimationFrame(step); });
+  const settings = [
+    { shoulder: 1, thigh: 1, elbow: 1, knee: 1 },
+    { shoulder: 0, thigh: 0, elbow: 0, knee: 0 },
+    { shoulder: 0.25, thigh: 0.5, elbow: 0.5, knee: 0.5 },
+    { shoulder: 0.5, thigh: 0.5, elbow: 0.5, knee: 0.5 },
+    { shoulder: 0, thigh: 0.5, elbow: 1, knee: 1 },
+    { shoulder: 0, thigh: 1, elbow: 1, knee: 1 },
+  ];
+  const out = [];
+  for (const s of settings) { window.__lab.setHelperFollow(s); await frames(6); out.push({ s: JSON.stringify(s), shirt: stretched(shirt), shorts: stretched(shorts) }); }
+  return out;
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/helper-joints-inspect.js

@@ -0,0 +1,10 @@
+(() => {
+  const a = window.__lab.actor;
+  const hj = a.helperJoints || [];
+  const counts = {}; for (const h of hj) counts[h.group] = (counts[h.group] || 0) + 1;
+  const bones = a.bones; const names = ['thigh_correctiveRoot_r', 'lowerarm_correctiveRoot_l', 'calf_correctiveRoot_r', 'upperarm_twistCor_01_l', 'upperarm_bicep_l', 'ankle_bck_r'];
+  const inMap = names.map((n) => n + ':' + (bones && bones.has(n)));
+  const re = /^thigh_correctiveRoot_[lr]$/;
+  const matchingKeys = bones ? [...bones.keys()].filter((k) => re.test(k)) : null;
+  return { helperJoints: hj.length, counts, bonesSize: bones ? bones.size : null, inMap, matchingKeys, follow: a.helperFollow };
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/outfit-bad-vertices.js

@@ -0,0 +1,26 @@
+(() => {
+  const model = window.__lab.actor.getModel();
+  const meshes = [];
+  model.traverse((o) => { if (o.isSkinnedMesh && /bodyShapeD/.test(o.material.name)) meshes.push(o); });
+  window.__lab.setLife(false);
+  model.updateMatrixWorld(true);
+  return meshes.map((m) => {
+    const pos = m.geometry.attributes.position, si = m.geometry.attributes.skinIndex, sw = m.geometry.attributes.skinWeight;
+    const V = m.position.constructor; const v = new V(), bind = new V();
+    const tally = new Map(); let bad = 0, maxD = 0; const examples = [];
+    for (let i = 0; i < pos.count; i++) {
+      bind.set(pos.getX(i), pos.getY(i), pos.getZ(i)); v.copy(bind);
+      m.applyBoneTransform(i, v);
+      const d = v.distanceTo(bind);
+      if (d > maxD) maxD = d;
+      if (d > 0.6) {
+        bad++;
+        const idx = [si.getX(i), si.getY(i), si.getZ(i), si.getW(i)], w = [sw.getX(i), sw.getY(i), sw.getZ(i), sw.getW(i)];
+        for (let k = 0; k < 4; k++) if (w[k] > 0.05) { const n = m.skeleton.bones[idx[k]].name; tally.set(n, (tally.get(n) || 0) + 1); }
+        if (examples.length < 3) examples.push({ i, d: +d.toFixed(2), bones: idx.map((j, k) => m.skeleton.bones[j].name + ':' + w[k].toFixed(2)) });
+      }
+    }
+    return { mesh: m.name, vertices: pos.count, badVertices: bad, maxDisplacement: +maxD.toFixed(2),
+      topBones: [...tally.entries()].sort((a, b) => b[1] - a[1]).slice(0, 14).map(([n, c]) => n + ' x' + c), examples };
+  });
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/outfit-body-material.js

@@ -0,0 +1,7 @@
+(() => {
+  const model = window.__lab.actor.getModel(); const meshes = []; let body = null;
+  model.traverse((o) => { if (o.isSkinnedMesh && /bodyShapeD/.test(o.material.name)) meshes.push(o); if (o.isSkinnedMesh && /Body_Baked/.test(o.material.name)) body = o; });
+  meshes.forEach((m) => { m.material = body.material; });
+  window.__lab.setLife(false);
+  return meshes.map((m) => m.name + ' now uses ' + body.material.type);
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/outfit-own-skeleton.js

@@ -0,0 +1,8 @@
+(() => {
+  const model = window.__lab.actor.getModel(); const meshes = [];
+  model.traverse((o) => { if (o.isSkinnedMesh && /bodyShapeD/.test(o.material.name)) meshes.push(o); });
+  const Skel = meshes[0].skeleton.constructor;
+  meshes.forEach((m) => { const old = m.skeleton; const fresh = new Skel(old.bones.slice(), old.boneInverses.map((x) => x.clone())); m.bind(fresh, m.bindMatrix); });
+  window.__lab.setLife(false);
+  return meshes.map((m) => m.name + ' rebound to its own Skeleton (' + m.skeleton.bones.length + ' bones)');
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/shirt-bone-ownership.js

@@ -0,0 +1,25 @@
+(() => {
+  const model = window.__lab.actor.getModel(); let shirt = null;
+  model.traverse((o) => { if (o.isSkinnedMesh && /Shirt/.test(o.material.name)) shirt = o; });
+  window.__lab.setLife(false);
+  model.updateMatrixWorld(true);
+  const M4 = shirt.matrixWorld.constructor, V = shirt.position.constructor, Q = shirt.quaternion.constructor;
+  const modelInv = new M4().copy(model.matrixWorld).invert();
+  const sk = shirt.skeleton;
+  const own = new Map();
+  const si = shirt.geometry.attributes.skinIndex, sw = shirt.geometry.attributes.skinWeight;
+  for (let i = 0; i < si.count; i++) {
+    const idx = [si.getX(i), si.getY(i), si.getZ(i), si.getW(i)], w = [sw.getX(i), sw.getY(i), sw.getZ(i), sw.getW(i)];
+    for (let k = 0; k < 4; k++) if (w[k] > 0.25) own.set(idx[k], (own.get(idx[k]) || 0) + 1);
+  }
+  const bindM = new M4(), curM = new M4(), p = new V(), q = new Q(), sc = new V(), p2 = new V(), q2 = new Q();
+  const rows = [...own.entries()].map(([j, count]) => {
+    const b = sk.bones[j];
+    bindM.copy(sk.boneInverses[j]).invert().decompose(p, q, sc);
+    curM.copy(modelInv).multiply(b.matrixWorld).decompose(p2, q2, sc);
+    const rot = Math.round(2 * Math.acos(Math.min(1, Math.abs(q.dot(q2)))) * 180 / Math.PI);
+    return { bone: b.name, count, dPos: +p.distanceTo(p2).toFixed(2), dRot: rot, parent: b.parent ? b.parent.name : '-' };
+  });
+  rows.sort((a, b) => b.count - a.count);
+  return rows.slice(0, 40).map((r) => `${r.bone}: ${r.count} verts, moved ${r.dPos} m / ${r.dRot} deg, parent ${r.parent}`);
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/shirt-edge-stretch.js

@@ -0,0 +1,26 @@
+(() => {
+  const model = window.__lab.actor.getModel(); let shirt = null;
+  model.traverse((o) => { if (o.isSkinnedMesh && /Shirt/.test(o.material.name)) shirt = o; });
+  window.__lab.setLife(false);
+  model.updateMatrixWorld(true);
+  const g = shirt.geometry, pos = g.attributes.position, si = g.attributes.skinIndex, sw = g.attributes.skinWeight, idx = g.index;
+  const V = shirt.position.constructor; const v = new V();
+  const skinned = new Float32Array(pos.count * 3);
+  for (let i = 0; i < pos.count; i++) { v.set(pos.getX(i), pos.getY(i), pos.getZ(i)); shirt.applyBoneTransform(i, v); skinned[i * 3] = v.x; skinned[i * 3 + 1] = v.y; skinned[i * 3 + 2] = v.z; }
+  const bones = (i) => { const out = []; const ids = [si.getX(i), si.getY(i), si.getZ(i), si.getW(i)], w = [sw.getX(i), sw.getY(i), sw.getZ(i), sw.getW(i)]; for (let k = 0; k < 4; k++) if (w[k] > 0.1) out.push(shirt.skeleton.bones[ids[k]].name + ':' + w[k].toFixed(2)); return out.join(' '); };
+  const edges = [];
+  const a = new V(), b = new V(), a2 = new V(), b2 = new V();
+  for (let t = 0; t < idx.count; t += 3) {
+    for (let e = 0; e < 3; e++) {
+      const i0 = idx.getX(t + e), i1 = idx.getX(t + (e + 1) % 3);
+      a.set(pos.getX(i0), pos.getY(i0), pos.getZ(i0)); b.set(pos.getX(i1), pos.getY(i1), pos.getZ(i1));
+      a2.set(skinned[i0 * 3], skinned[i0 * 3 + 1], skinned[i0 * 3 + 2]); b2.set(skinned[i1 * 3], skinned[i1 * 3 + 1], skinned[i1 * 3 + 2]);
+      const l0 = a.distanceTo(b), l1 = a2.distanceTo(b2);
+      if (l0 > 1e-6 && l1 / l0 > 3) edges.push({ ratio: +(l1 / l0).toFixed(1), len: +l1.toFixed(3), i0, i1 });
+    }
+  }
+  edges.sort((x, y) => y.ratio - x.ratio);
+  const pairs = new Map();
+  for (const e of edges.slice(0, 400)) { const key = bones(e.i0) + '  <->  ' + bones(e.i1); pairs.set(key, (pairs.get(key) || 0) + 1); }
+  return { stretchedEdges: edges.length, worst: edges.slice(0, 8), commonPairs: [...pairs.entries()].sort((x, y) => y[1] - x[1]).slice(0, 12).map(([k, c]) => c + 'x  ' + k) };
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/shirt-long-edges.js

@@ -0,0 +1,23 @@
+(() => {
+  const model = window.__lab.actor.getModel(); let shirt = null;
+  model.traverse((o) => { if (o.isSkinnedMesh && /Shirt/.test(o.material.name)) shirt = o; });
+  window.__lab.setLife(false);
+  model.updateMatrixWorld(true);
+  const g = shirt.geometry, pos = g.attributes.position, si = g.attributes.skinIndex, sw = g.attributes.skinWeight, idx = g.index;
+  const V = shirt.position.constructor; const v = new V();
+  const sk = new Float32Array(pos.count * 3);
+  for (let i = 0; i < pos.count; i++) { v.set(pos.getX(i), pos.getY(i), pos.getZ(i)); shirt.applyBoneTransform(i, v); sk[i * 3] = v.x; sk[i * 3 + 1] = v.y; sk[i * 3 + 2] = v.z; }
+  const bones = (i) => { const out = []; const ids = [si.getX(i), si.getY(i), si.getZ(i), si.getW(i)], w = [sw.getX(i), sw.getY(i), sw.getZ(i), sw.getW(i)]; for (let k = 0; k < 4; k++) if (w[k] > 0.1) out.push(shirt.skeleton.bones[ids[k]].name + ':' + w[k].toFixed(2)); return out.join(' '); };
+  const edges = []; const a = new V(), b = new V(), a2 = new V(), b2 = new V();
+  let bindLenMax = 0, over15 = 0, over30 = 0;
+  for (let t = 0; t < idx.count; t += 3) for (let e = 0; e < 3; e++) {
+    const i0 = idx.getX(t + e), i1 = idx.getX(t + (e + 1) % 3); if (i0 > i1) continue;
+    a.set(pos.getX(i0), pos.getY(i0), pos.getZ(i0)); b.set(pos.getX(i1), pos.getY(i1), pos.getZ(i1));
+    a2.set(sk[i0 * 3], sk[i0 * 3 + 1], sk[i0 * 3 + 2]); b2.set(sk[i1 * 3], sk[i1 * 3 + 1], sk[i1 * 3 + 2]);
+    const l0 = a.distanceTo(b), l1 = a2.distanceTo(b2); if (l0 > bindLenMax) bindLenMax = l0;
+    if (l1 > 0.15) over15++; if (l1 > 0.30) over30++;
+    if (l1 > 0.12) edges.push({ len: +l1.toFixed(3), bind: +l0.toFixed(4), i0, i1, b0: bones(i0), b1: bones(i1), p0: [a.x, a.y, a.z].map((x) => +x.toFixed(2)), p1: [b.x, b.y, b.z].map((x) => +x.toFixed(2)) });
+  }
+  edges.sort((x, y) => y.len - x.len);
+  return { longestBindEdge: +bindLenMax.toFixed(3), edgesOver15cm: over15, edgesOver30cm: over30, top: edges.slice(0, 10) };
+})()

package/assets/metahuman/tools/metahuman/e2e/probes/walk-sampler.js

@@ -0,0 +1,105 @@
+// Installs window.__walk: samples bone heights + shirt-vs-shoulder offsets every frame.
+(() => {
+  const model = window.__lab.actor.getModel();
+  const V = model.position.constructor;
+  let shirt = null, body = null; const bones = {};
+  model.traverse((o) => {
+    if (o.isBone) bones[o.name] = o;
+    if (o.isSkinnedMesh && /Shirt/i.test(o.material.name)) shirt = o;
+    if (o.isSkinnedMesh && /Body|Skin/i.test(o.material.name) && !body) body = o;
+  });
+  const want = ['root', 'pelvis', 'spine_01', 'spine_03', 'spine_05', 'neck_01', 'head', 'clavicle_l', 'upperarm_l', 'upperarm_r', 'thigh_l', 'calf_l', 'foot_l', 'foot_r', 'ball_l'];
+  const v = new V(), wp = new V();
+  const pos = shirt.geometry.attributes.position;
+  // Collar markers: the 40 highest shirt vertices at rest (bind pose) — track their skinned mean height.
+  const order = Array.from({ length: pos.count }, (_, i) => i).sort((a, b) => pos.getY(b) - pos.getY(a)).slice(0, 40);
+  // Deltoid exposure: body vertices near/above the shoulder joint at rest vs shirt vertices in the same region.
+  const bindPosOf = (name) => { const sk = body.skeleton; const i = sk.bones.findIndex((b) => b.name === name); const m = sk.boneInverses[i].clone().invert(); return new V().setFromMatrixPosition(m); };
+  const region = (mesh, joint, r) => { const p = mesh.geometry.attributes.position; const out = []; for (let i = 0; i < p.count; i++) { const dx = p.getX(i) - joint.x, dy = p.getY(i) - joint.y, dz = p.getZ(i) - joint.z; if (dy > 0.0 && dx * dx + dz * dz < r * r && dy < 0.12) out.push(i); } return out; };
+  const jL = bindPosOf('upperarm_l');
+  const bodyL = region(body, jL, 0.07), shirtL = region(shirt, jL, 0.09);
+  const maxY = (mesh, ids) => { const p = mesh.geometry.attributes.position; let m = -Infinity; for (const i of ids) { v.set(p.getX(i), p.getY(i), p.getZ(i)); mesh.applyBoneTransform(i, v); v.applyMatrix4(mesh.matrixWorld); if (v.y > m) m = v.y; } return m; };
+  // Skin-through-shirt penetration at the shoulder tops. The exported body mesh is culled under the
+  // shirt (it tops out at y≈1.37), so the visible skin there is the FACE mesh's neck skirt plus the
+  // arm tops: pair skin vertices from every skin mesh in the shoulder band with the nearest shirt
+  // vertex at rest, keep the rest outward gap, and per frame measure how far the skin moved outward
+  // relative to the shirt (positive = penetration depth in mm beyond the rest gap).
+  const skinMeshes = []; model.traverse((o) => { if (o.isSkinnedMesh && /Body|Face_Skin/i.test(o.material.name)) skinMeshes.push(o); });
+  const neck = bindPosOf('neck_01');
+  const pairs = [];
+  {
+    const sp = shirt.geometry.attributes.position;
+    const shirtIdx = []; for (let i = 0; i < sp.count; i++) if (sp.getY(i) > 1.30) shirtIdx.push(i);
+    for (const mesh of skinMeshes) {
+      const bp = mesh.geometry.attributes.position;
+      for (let i = 0; i < bp.count; i++) {
+        const x = bp.getX(i), y = bp.getY(i), z = bp.getZ(i);
+        if (y < neck.y - 0.13 || y > neck.y + 0.03) continue;
+        if (Math.abs(x) < 0.03 || Math.abs(x) > 0.24) continue;
+        let best = -1, bd = 1e9;
+        for (const j of shirtIdx) { const dx = sp.getX(j) - x, dy = sp.getY(j) - y, dz = sp.getZ(j) - z; const d2 = dx * dx + dy * dy + dz * dz; if (d2 < bd) { bd = d2; best = j; } }
+        if (best < 0 || bd > 0.025 * 0.025) continue;
+        const n = new V(sp.getX(best) - x, sp.getY(best) - y, sp.getZ(best) - z); const len = n.length(); if (len < 1e-4) continue;
+        n.multiplyScalar(1 / len);
+        // Only skin that the shirt actually covers: the shirt vertex must lie along the skin normal.
+        const nn = mesh.geometry.attributes.normal; const sn = new V(nn.getX(i), nn.getY(i), nn.getZ(i)).normalize();
+        if (n.dot(sn) < 0.6) continue;
+        pairs.push({ mesh, b: i, s: best, n, rest: len });
+      }
+    }
+  }
+  const bonesOf = (mesh, i) => { const si = mesh.geometry.attributes.skinIndex, sw = mesh.geometry.attributes.skinWeight; const ids = [si.getX(i), si.getY(i), si.getZ(i), si.getW(i)], w = [sw.getX(i), sw.getY(i), sw.getZ(i), sw.getW(i)]; const out = []; for (let k = 0; k < 4; k++) if (w[k] > 0.05) out.push(mesh.skeleton.bones[ids[k]].name + ':' + w[k].toFixed(2)); return out.join(' '); };
+  const vb = new V(), vs = new V(), nq = new V();
+  const poke = (wantWorst) => {
+    const sp = shirt.geometry.attributes.position;
+    let worst = -Infinity, sum = 0, n = 0, worstPair = null; const depths = [];
+    for (const pr of pairs) {
+      const bp = pr.mesh.geometry.attributes.position;
+      vb.set(bp.getX(pr.b), bp.getY(pr.b), bp.getZ(pr.b)); pr.mesh.applyBoneTransform(pr.b, vb); vb.applyMatrix4(pr.mesh.matrixWorld);
+      vs.set(sp.getX(pr.s), sp.getY(pr.s), sp.getZ(pr.s)); shirt.applyBoneTransform(pr.s, vs); vs.applyMatrix4(shirt.matrixWorld);
+      nq.copy(pr.n).applyQuaternion(model.quaternion);
+      const gap = vs.sub(vb).dot(nq);
+      const depth = (pr.rest - gap) * 1000;
+      depths.push(depth);
+      if (depth > worst) { worst = depth; worstPair = pr; }
+      sum += depth; n++;
+    }
+    depths.sort((a, b) => b - a);
+    const r = { worst: +worst.toFixed(1), p90: +(depths[Math.floor(depths.length * 0.1)] || 0).toFixed(1), mean: +(sum / Math.max(1, n)).toFixed(1) };
+    if (wantWorst && worstPair) { r.skinBones = bonesOf(worstPair.mesh, worstPair.b); r.shirtBones = bonesOf(shirt, worstPair.s); r.mesh = worstPair.mesh.material.name; }
+    return r;
+  };
+  window.__poke = poke;
+  const samples = [];
+  const pl = typeof window.__lab.playerLoader === 'function' ? window.__lab.playerLoader() : window.__lab.playerLoader;
+  const ac = pl.getAnimationController && pl.getAnimationController();
+  const mixBones = (name) => { const mp = ac && (ac.getTrackAMixamoPlayer() || ac.getTrackBMixamoPlayer()); const sk = mp && mp.skeleton; let hit = null; if (sk) sk.traverse((o) => { if (!hit && o.name.replace(/^mixamorig\d*/, '') === name) hit = o; }); return hit; };
+  const pitch = (a, b) => { if (!a || !b) return null; const pa = a.getWorldPosition(new V()), pb = b.getWorldPosition(new V()); const d = pb.sub(pa); return +(Math.asin(d.y / d.length()) * 180 / Math.PI).toFixed(1); };
+  let raf = 0; const t0 = performance.now();
+  const tick = () => {
+    model.updateMatrixWorld(true);
+    const s = { t: +((performance.now() - t0) / 1000).toFixed(2) };
+    const playerY = window.__lab.playerPosition().y;
+    s.rigClavPitchL = pitch(bones.clavicle_l, bones.upperarm_l);
+    s.rigClavPitchR = pitch(bones.clavicle_r, bones.upperarm_r);
+    s.clipClavPitchL = pitch(mixBones('LeftShoulder'), mixBones('LeftArm'));
+    const mh = mixBones('Hips'), mf = mixBones('LeftFoot'), mf2 = mixBones('RightFoot'), mhead = mixBones('Head'), msh = mixBones('LeftArm');
+    if (mh && mf && mf2) { const hy = mh.getWorldPosition(new V()).y, fy = Math.min(mf.getWorldPosition(new V()).y, mf2.getWorldPosition(new V()).y); s.clipHipsAboveFoot = +(hy - fy).toFixed(3); if (mhead) s.clipHeadAboveFoot = +(mhead.getWorldPosition(new V()).y - fy).toFixed(3); if (msh) s.clipShoulderAboveHips = +(msh.getWorldPosition(new V()).y - hy).toFixed(3); }
+    for (const n of want) { const b = bones[n]; if (!b) continue; b.getWorldPosition(wp); s[n] = +(wp.y - playerY).toFixed(3); }
+    s.pelvisLocal = bones.pelvis ? bones.pelvis.position.toArray().map((x) => +x.toFixed(3)) : null;
+    let sy = 0; for (const i of order) { v.set(pos.getX(i), pos.getY(i), pos.getZ(i)); shirt.applyBoneTransform(i, v); v.applyMatrix4(shirt.matrixWorld); sy += v.y; }
+    s.collarY = +(sy / order.length - playerY).toFixed(3);
+    s.shoulderY = +(((s.upperarm_l ?? 0) + (s.upperarm_r ?? 0)) / 2).toFixed(3);
+    s.collarAboveShoulder = +(s.collarY - s.shoulderY).toFixed(3);
+    const pk = poke(false); s.pokeWorstMm = pk.worst; s.pokeP90Mm = pk.p90; s.pokeMeanMm = pk.mean;
+    if (body && bodyL.length && shirtL.length) s.skinAboveShirtL = +(maxY(body, bodyL) - maxY(shirt, shirtL)).toFixed(3);
+    const mp0 = ac && (ac.getTrackAMixamoPlayer() || ac.getTrackBMixamoPlayer());
+    s.clip = mp0 && (mp0.currentClipName || (mp0.currentAction && mp0.currentAction.getClip && mp0.currentAction.getClip().name) || null);
+    samples.push(s);
+    raf = requestAnimationFrame(tick);
+  };
+  raf = requestAnimationFrame(tick);
+  window.__walk = { finish: () => { cancelAnimationFrame(raf); return samples; }, shirtVerts: pos.count, shirtName: shirt.material.name, bodyName: body && body.material.name };
+  const mp = ac && (ac.getTrackAMixamoPlayer() || ac.getTrackBMixamoPlayer());
+  return { installed: true, shirt: shirt.material.name, skinMeshes: skinMeshes.map((m) => m.material.name), pairs: pairs.length, hasMixamoSkeleton: !!(mp && mp.skeleton), mixamoKeys: mp ? Object.keys(mp).filter((k) => /clip|action|name/i.test(k)).slice(0, 12) : [] };
+})()

package/assets/metahuman/tools/metahuman/e2e/shot.mjs

@@ -0,0 +1,125 @@
+// Headless screenshot rig for a MetaHuman character: real Chrome (WebGPU), starts the game, checks that
+// the hair stays on the head while walking and turning, that locomotion moves the player, then frames the
+// character from several angles. Run from the project root, against the game port `bitmagic dev` printed:
+//   node tools/metahuman/e2e/shot.mjs [port]      → tools/metahuman/e2e/shots/*.png
+// Needs `window.__lab` (installMetaHumanLabHooks in src/work/metahuman/MetaHumanLabHooks.ts).
+import { chromium } from 'playwright-core';
+import fs from 'node:fs';
+
+const PORT = process.argv[2] || process.env.GAME_PORT || '3010';
+const OUT = new URL('./shots/', import.meta.url).pathname;
+fs.mkdirSync(OUT, { recursive: true });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const browser = await chromium.launch({
+  channel: 'chrome', headless: true,
+  args: ['--use-angle=metal', '--enable-unsafe-webgpu', '--window-size=1600,900', '--autoplay-policy=no-user-gesture-required'],
+});
+const watchdog = setTimeout(async () => { console.log('[e2e] watchdog: closing the browser'); try { await browser.close(); } catch {} process.exit(2); }, 240000);
+try {
+  const page = await browser.newPage({ viewport: { width: 1600, height: 900 }, deviceScaleFactor: 1 });
+  const errors = [];
+  page.on('pageerror', (e) => errors.push('pageerror: ' + e.message));
+  page.on('console', (m) => {
+    const t = m.text();
+    if (m.type() === 'error' || /\[MetaHuman|skinned|retarget|PlayerLoader: (Rendering|Applied|Creating)/.test(t)) console.log(`PAGE[${m.type()}]:`, t.slice(0, 300));
+  });
+  const shot = async (name) => { await page.screenshot({ path: OUT + name + '.png' }); console.log('[shot]', name); };
+  const bodyText = () => page.evaluate(() => document.body.innerText || '');
+  async function waitFor(fn, timeoutMs, label) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      if (await fn()) { console.log(`[e2e] ${label} (+${((Date.now() - start) / 1000).toFixed(1)}s)`); return true; }
+      await sleep(400);
+    }
+    console.log(`[e2e] TIMEOUT: ${label}`); await shot('TIMEOUT-' + label.replace(/\W+/g, '_')); return false;
+  }
+
+  await page.goto(`http://localhost:${PORT}/`, { waitUntil: 'load' });
+  await waitFor(async () => /PLAY/i.test(await bodyText()), 60000, 'menu');
+  await sleep(800);
+  const playBtn = page.getByText(/^\s*PLAY\s*$/i).first();
+  if (await playBtn.count()) await playBtn.click({ force: true }); else await page.mouse.click(800, 650);
+  await waitFor(() => page.evaluate(() => !!(window.__lab && window.__lab.actor && window.__lab.actor.getModel())), 90000, 'metahuman loaded');
+  await sleep(3500); // textures, shadows, floor snap
+  const lab = (code) => page.evaluate(code);
+  await lab('window.__lab.setLife(false)');
+  await shot('01-wide-back');
+
+  // Locomotion: hold W and watch the engine drive the skeleton; the hair must ride the head throughout.
+  const p0 = await lab('window.__lab.playerPosition()');
+  const hairProbe = `(() => { const a = window.__lab.actor; const head = a.getBone('head'); const model = a.getModel(); let hair = null;
+    model.traverse((o) => { if (!hair && o.isMesh && /^Hair_/.test(o.name) && !/__blend/.test(o.name)) hair = o; });
+    if (!hair || !head) return null;
+    hair.geometry.computeBoundingBox(); const c = hair.geometry.boundingBox.getCenter(hair.position.clone());
+    hair.updateWorldMatrix(true, false); const cw = hair.localToWorld(c); const hp = head.getWorldPosition(hair.position.clone()); return cw.distanceTo(hp); })()`;
+  const hairSamples = [];
+  await page.keyboard.down('KeyW');
+  for (let i = 0; i < 9; i++) { await sleep(150); hairSamples.push(await lab(hairProbe)); }
+  await shot('14-walk'); await sleep(500); await shot('14-walk-b');
+  await page.keyboard.up('KeyW'); await sleep(300);
+  await page.keyboard.down('Space'); await sleep(120); await page.keyboard.up('Space');
+  for (let i = 0; i < 8; i++) { await sleep(120); hairSamples.push(await lab(hairProbe)); }
+  await sleep(700);
+  const valid = hairSamples.filter((x) => typeof x === 'number');
+  if (valid.length) {
+    const hMin = Math.min(...valid), hMax = Math.max(...valid);
+    console.log('[e2e] hair↔head distance while walking + jumping:', hMin.toFixed(4), '…', hMax.toFixed(4), 'm', (hMax - hMin) < 0.003 ? 'HAIR STAYS ON HEAD ✓' : 'HAIR DRIFTS ✗');
+  } else console.log('[e2e] no Hair_* card mesh found — hair check skipped');
+  const p1 = await lab('window.__lab.playerPosition()');
+  const moved = p0 && p1 ? Math.hypot(p1.x - p0.x, p1.z - p0.z) : 0;
+  console.log('[e2e] walked', moved.toFixed(2), 'm', moved > 0.5 ? 'LOCOMOTION ✓' : 'DID NOT MOVE ✗');
+  await shot('15-idle-after-walk');
+
+  // Deterministic framing around the head: dx = to the character's right, dz = in front of it.
+  const head = await lab('window.__lab.headPosition()');
+  const facing = await lab('window.__lab.facing()');
+  const right = { x: -facing.z, z: facing.x };
+  console.log('[e2e] facing', JSON.stringify(facing), 'head', JSON.stringify(head));
+  const frame = async (name, dx, dy, dz, lookDy, fov) => {
+    const px = head.x + right.x * dx + facing.x * dz, pz = head.z + right.z * dx + facing.z * dz;
+    await lab(`window.__lab.freeCam({x:${px},y:${head.y + dy},z:${pz}},{x:${head.x},y:${head.y + lookDy},z:${head.z}},${fov})`);
+    await sleep(700); await shot(name);
+  };
+  await frame('02-front-full', 0, -0.35, 3.6, -0.75, 38);
+  await frame('03-face', 0, 0.02, 0.62, 0.0, 30);
+  await frame('04-face-three-quarter', 0.42, 0.06, 0.5, 0.0, 30);
+  await frame('05-face-profile', 0.7, 0.03, 0.06, 0.0, 30);
+  await frame('06-hair-back-top', -0.1, 0.45, -0.55, 0.15, 32);
+  await frame('07-eye-macro', 0.05, 0.02, 0.28, 0.02, 22);
+  await lab('window.__lab.setLife(true)');
+  await lab(`window.__lab.freeCam({x:${head.x + right.x * 0.25 + facing.x * 0.75},y:${head.y + 0.05},z:${head.z + right.z * 0.25 + facing.z * 0.75}},{x:${head.x},y:${head.y},z:${head.z}},30)`);
+  await sleep(2500); await shot('10-life-on-front');
+
+  // Hair-follows-head: the head-bone → hair-bbox-centre distance must not change between rest and a big
+  // head turn (the cards are rigidly parented to the head bone).
+  const hairMetric = () => page.evaluate(() => {
+    const a = window.__lab.actor; const head = a.getBone('head'); const model = a.getModel();
+    let hair = null; model.traverse((o) => { if (!hair && o.isMesh && /Hair_/.test(o.name) && !/__blend/.test(o.name)) hair = o; });
+    if (!hair || !head) return null;
+    hair.geometry.computeBoundingBox(); const c = hair.geometry.boundingBox.getCenter(hair.position.clone());
+    hair.updateWorldMatrix(true, false); const cw = hair.localToWorld(c);
+    const hp = head.getWorldPosition(hair.position.clone());
+    const rest = a.head && a.head.restQuat; const qn = head.quaternion;
+    const d = rest ? Math.abs(rest.x * qn.x + rest.y * qn.y + rest.z * qn.z + rest.w * qn.w) : 1;
+    return { dist: cw.distanceTo(hp), headTurnDeg: 2 * Math.acos(Math.min(1, d)) * 180 / Math.PI };
+  });
+  await lab('window.__lab.setLife(false)'); await sleep(600);
+  const restMetric = await hairMetric();
+  await lab('window.__lab.setLife(true)');
+  await lab(`window.__lab.freeCam({x:${head.x + right.x * 0.9 + facing.x * 0.9},y:${head.y + 1.1},z:${head.z + right.z * 0.9 + facing.z * 0.9}},{x:${head.x},y:${head.y},z:${head.z}},34)`);
+  await sleep(3000); await shot('11-life-head-turn-high');
+  const turnMetric = await hairMetric();
+  if (restMetric && turnMetric) {
+    console.log('[e2e] hair↔head distance at rest', restMetric.dist.toFixed(4), 'm; after head turn', turnMetric.dist.toFixed(4), 'm;',
+      'head turn from rest', restMetric.headTurnDeg.toFixed(1), '°→', turnMetric.headTurnDeg.toFixed(1), '°;',
+      Math.abs(restMetric.dist - turnMetric.dist) < 0.002 ? 'HAIR FOLLOWS HEAD ✓' : 'HAIR DETACHED ✗');
+  }
+  await lab('window.__lab.freeCamOff()');
+  const info = await page.evaluate(() => {
+    const a = window.__lab.actor; const r = a.getReport();
+    return { morphs: a.getMorphNames().length, byPart: r && r.byPart, hidden: r && r.hiddenMeshes, blendClones: r && r.blendClones.length };
+  });
+  console.log('[e2e] report', JSON.stringify(info));
+  if (errors.length) console.log('[e2e] page errors:\n' + errors.join('\n'));
+} finally { clearTimeout(watchdog); try { await browser.close(); } catch {} }

package/assets/metahuman/tools/metahuman/e2e/walk-probe.mjs

@@ -0,0 +1,43 @@
+// Boot the game, install the walk sampler, hold W for a while, release, and print idle-vs-walking stats.
+//   node tools/metahuman/e2e/walk-probe.mjs [port]   (env FOLLOW='{"shoulder":0.4}' sets helperFollow first; SHOT=file.png;
+//   PROBE=file.js / PROBE_MID=file.js evaluate extra probes after / during the walk). Outputs: tools/metahuman/e2e/shots/.
+import { chromium } from 'playwright-core';
+import fs from 'node:fs';
+const PORT = process.argv[2] || '3010';
+const HERE = new URL('./', import.meta.url).pathname; const SHOTS = HERE + 'shots/'; fs.mkdirSync(SHOTS, { recursive: true });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const browser = await chromium.launch({ channel: 'chrome', headless: true, args: ['--use-angle=metal', '--enable-unsafe-webgpu', '--window-size=1280,720', '--autoplay-policy=no-user-gesture-required'] });
+const watchdog = setTimeout(async () => { try { await browser.close(); } catch {} process.exit(2); }, 180000);
+try {
+  const page = await browser.newPage({ viewport: { width: 1280, height: 720 } });
+  await page.goto(`http://localhost:${PORT}/`, { waitUntil: 'load' });
+  const start = Date.now();
+  while (Date.now() - start < 90000 && !/PLAY/i.test(await page.evaluate(() => document.body.innerText || ''))) await sleep(400);
+  await sleep(600);
+  const btn = page.getByText(/^\s*PLAY\s*$/i).first(); if (await btn.count()) await btn.click({ force: true }); else await page.mouse.click(640, 520);
+  while (Date.now() - start < 150000 && !(await page.evaluate(() => !!(window.__lab && window.__lab.actor && window.__lab.actor.getModel())))) await sleep(400);
+  await sleep(4000);
+  await page.evaluate(() => { window.__lab.freeCamOff(); if (window.__lab.orbitTo) window.__lab.orbitTo(0, 1.25, 3.4); });
+  const info = await page.evaluate(fs.readFileSync(HERE + 'probes/walk-sampler.js', 'utf8'));
+  console.log('[sampler]', JSON.stringify(info));
+  const FOLLOW = process.env.FOLLOW ? JSON.parse(process.env.FOLLOW) : null;
+  if (FOLLOW) { await page.evaluate((f) => window.__lab.setHelperFollow(f), FOLLOW); console.log('[follow]', JSON.stringify(FOLLOW)); }
+  await sleep(1200);                       // idle baseline
+  const idlePoke = await page.evaluate(() => window.__poke(true)); console.log('[poke idle]', JSON.stringify(idlePoke));
+  await page.keyboard.down('KeyW'); await sleep(1400);
+  if (process.env.SHOT) { await page.screenshot({ path: process.env.SHOT }); console.log('[shot]', process.env.SHOT); }
+  const midWalk = await page.evaluate(() => window.__poke(true)); console.log('[poke mid-walk]', JSON.stringify(midWalk));
+  if (process.env.PROBE_MID) { const extra = await page.evaluate(fs.readFileSync(process.env.PROBE_MID, 'utf8')); fs.writeFileSync(SHOTS + 'walk-extra-mid.json', JSON.stringify(extra)); console.log('[extra-mid] written'); }
+  await sleep(1200); await page.keyboard.up('KeyW');
+  await sleep(1500);                       // back to idle
+  const samples = await page.evaluate(() => window.__walk.finish());
+  if (process.env.PROBE) { const extra = await page.evaluate(fs.readFileSync(process.env.PROBE, 'utf8')); fs.writeFileSync(SHOTS + 'walk-extra.json', JSON.stringify(extra)); console.log('[extra] written tools/metahuman/e2e/shots/walk-extra.json'); }
+  const clips = [...new Set(samples.map((x) => x.clip))]; console.log('[clips]', JSON.stringify(clips));
+  fs.writeFileSync(SHOTS + 'walk-samples.json', JSON.stringify(samples));
+  const idle = samples.filter((s) => s.t < 1.1), walk = samples.filter((s) => s.t > 1.8 && s.t < 3.6), after = samples.filter((s) => s.t > 4.6);
+  const stat = (arr, k) => { const v = arr.map((s) => s[k]).filter((x) => typeof x === 'number'); return v.length ? `${Math.min(...v).toFixed(3)}..${Math.max(...v).toFixed(3)} (mean ${(v.reduce((a, b) => a + b, 0) / v.length).toFixed(3)})` : '-'; };
+  for (const k of (process.env.KEYS ? process.env.KEYS.split(',') : ['pelvis', 'shoulderY', 'collarAboveShoulder', 'skinAboveShirtL', 'rigClavPitchL', 'clipClavPitchL', 'clipHipsAboveFoot', 'clipShoulderAboveHips'])) console.log(`${k.padEnd(20)} idle ${stat(idle, k).padEnd(30)} walk ${stat(walk, k).padEnd(30)} after ${stat(after, k)}`);
+  const pl = (arr) => arr.slice(0, 3).map((s) => JSON.stringify(s.pelvisLocal)).join(' ');
+  console.log('pelvisLocal idle', pl(idle), ' walk', pl(walk));
+  console.log('samples', samples.length);
+} finally { clearTimeout(watchdog); await browser.close(); }